home *** CD-ROM | disk | FTP | other *** search
/ Windows Expert / Windows Expert.iso / windownt / awksrc.zip / AWKTAB.001 < prev    next >
Text File  |  1992-09-23  |  87KB  |  2,868 lines
  1.  
  2. # line 27 "awk.y"
  3. #ifdef DEBUG
  4. #define YYDEBUG 12
  5. #endif
  6.  
  7. #define    YYMAXDEPTH    300
  8. #define    YYSSIZE    YYMAXDEPTH
  9.  
  10. #include "awk.h"
  11.  
  12. static void yyerror (); /* va_alist */
  13. static char *get_src_buf P((void));
  14. static int yylex P((void));
  15. static NODE *node_common P((NODETYPE op));
  16. static NODE *snode P((NODE *subn, NODETYPE op, int sindex));
  17. static NODE *mkrangenode P((NODE *cpair));
  18. static NODE *make_for_loop P((NODE *init, NODE *cond, NODE *incr));
  19. static NODE *append_right P((NODE *list, NODE *new));
  20. static void func_install P((NODE *params, NODE *def));
  21. static void pop_var P((NODE *np, int freeit));
  22. static void pop_params P((NODE *params));
  23. static NODE *make_param P((char *name));
  24. static NODE *mk_rexp P((NODE *exp));
  25.  
  26. static int want_assign;        /* lexical scanning kludge */
  27. static int want_regexp;        /* lexical scanning kludge */
  28. static int can_return;        /* lexical scanning kludge */
  29. static int io_allowed = 1;    /* lexical scanning kludge */
  30. static char *lexptr;        /* pointer to next char during parsing */
  31. static char *lexend;
  32. static char *lexptr_begin;    /* keep track of where we were for error msgs */
  33. static char *lexeme;        /* beginning of lexeme for debugging */
  34. static char *thisline = NULL;
  35. #define YYDEBUG_LEXER_TEXT (lexeme)
  36. static int param_counter;
  37. static char *tokstart = NULL;
  38. static char *token = NULL;
  39. static char *tokend;
  40.  
  41. NODE *variables[HASHSIZE];
  42.  
  43. extern char *source;
  44. extern int sourceline;
  45. extern char *cmdline_src;
  46. extern char **srcfiles;
  47. extern int errcount;
  48. extern NODE *begin_block;
  49. extern NODE *end_block;
  50.  
  51. # line 76 "awk.y"
  52. typedef union  {
  53.     long lval;
  54.     AWKNUM fval;
  55.     NODE *nodeval;
  56.     NODETYPE nodetypeval;
  57.     char *sval;
  58.     NODE *(*ptrval)();
  59. } YYSTYPE;
  60. # define FUNC_CALL 257
  61. # define NAME 258
  62. # define REGEXP 259
  63. # define ERROR 260
  64. # define YNUMBER 261
  65. # define YSTRING 262
  66. # define RELOP 263
  67. # define APPEND_OP 264
  68. # define ASSIGNOP 265
  69. # define MATCHOP 266
  70. # define NEWLINE 267
  71. # define CONCAT_OP 268
  72. # define LEX_BEGIN 269
  73. # define LEX_END 270
  74. # define LEX_IF 271
  75. # define LEX_ELSE 272
  76. # define LEX_RETURN 273
  77. # define LEX_DELETE 274
  78. # define LEX_WHILE 275
  79. # define LEX_DO 276
  80. # define LEX_FOR 277
  81. # define LEX_BREAK 278
  82. # define LEX_CONTINUE 279
  83. # define LEX_PRINT 280
  84. # define LEX_PRINTF 281
  85. # define LEX_NEXT 282
  86. # define LEX_EXIT 283
  87. # define LEX_FUNCTION 284
  88. # define LEX_GETLINE 285
  89. # define LEX_IN 286
  90. # define LEX_AND 287
  91. # define LEX_OR 288
  92. # define INCREMENT 289
  93. # define DECREMENT 290
  94. # define LEX_BUILTIN 291
  95. # define LEX_LENGTH 292
  96. # define UNARY 293
  97. #define yyclearin yychar = -1
  98. #define yyerrok yyerrflag = 0
  99. extern int yychar;
  100. extern int yyerrflag;
  101. #ifndef YYMAXDEPTH
  102. #define YYMAXDEPTH 150
  103. #endif
  104. YYSTYPE yylval, yyval;
  105. # define YYERRCODE 256
  106.  
  107. # line 751 "awk.y"
  108.  
  109.  
  110. struct token {
  111.     char *operator;        /* text to match */
  112.     NODETYPE value;        /* node type */
  113.     int class;        /* lexical class */
  114.     unsigned flags;        /* # of args. allowed and compatability */
  115. #    define    ARGS    0xFF    /* 0, 1, 2, 3 args allowed (any combination */
  116. #    define    A(n)    (1<<(n))
  117. #    define    VERSION    0xFF00    /* old awk is zero */
  118. #    define    NOT_OLD        0x0100    /* feature not in old awk */
  119. #    define    NOT_POSIX    0x0200    /* feature not in POSIX */
  120. #    define    GAWKX        0x0400    /* gawk extension */
  121.     NODE *(*ptr) ();    /* function that implements this keyword */
  122. };
  123.  
  124. extern NODE
  125.     *do_exp(),    *do_getline(),    *do_index(),    *do_length(),
  126.     *do_sqrt(),    *do_log(),    *do_sprintf(),    *do_substr(),
  127.     *do_split(),    *do_system(),    *do_int(),    *do_close(),
  128.     *do_atan2(),    *do_sin(),    *do_cos(),    *do_rand(),
  129.     *do_srand(),    *do_match(),    *do_tolower(),    *do_toupper(),
  130.     *do_sub(),    *do_gsub(),    *do_strftime(),    *do_systime();
  131.  
  132. /* Tokentab is sorted ascii ascending order, so it can be binary searched. */
  133.  
  134. static struct token tokentab[] = {
  135. {"BEGIN",    Node_illegal,     LEX_BEGIN,    0,        0},
  136. {"END",        Node_illegal,     LEX_END,    0,        0},
  137. {"atan2",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(2),    do_atan2},
  138. {"break",    Node_K_break,     LEX_BREAK,    0,        0},
  139. {"close",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_close},
  140. {"continue",    Node_K_continue, LEX_CONTINUE,    0,        0},
  141. {"cos",        Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_cos},
  142. {"delete",    Node_K_delete,     LEX_DELETE,    NOT_OLD,    0},
  143. {"do",        Node_K_do,     LEX_DO,    NOT_OLD,    0},
  144. {"else",    Node_illegal,     LEX_ELSE,    0,        0},
  145. {"exit",    Node_K_exit,     LEX_EXIT,    0,        0},
  146. {"exp",        Node_builtin,     LEX_BUILTIN,    A(1),        do_exp},
  147. {"for",        Node_K_for,     LEX_FOR,    0,        0},
  148. {"func",    Node_K_function, LEX_FUNCTION,    NOT_POSIX|NOT_OLD,    0},
  149. {"function",    Node_K_function, LEX_FUNCTION,    NOT_OLD,    0},
  150. {"getline",    Node_K_getline,     LEX_GETLINE,    NOT_OLD,    0},
  151. {"gsub",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(2)|A(3), do_gsub},
  152. {"if",        Node_K_if,     LEX_IF,    0,        0},
  153. {"in",        Node_illegal,     LEX_IN,    0,        0},
  154. {"index",    Node_builtin,     LEX_BUILTIN,    A(2),        do_index},
  155. {"int",        Node_builtin,     LEX_BUILTIN,    A(1),        do_int},
  156. {"length",    Node_builtin,     LEX_LENGTH,    A(0)|A(1),    do_length},
  157. {"log",        Node_builtin,     LEX_BUILTIN,    A(1),        do_log},
  158. {"match",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(2),    do_match},
  159. {"next",    Node_K_next,     LEX_NEXT,    0,        0},
  160. {"print",    Node_K_print,     LEX_PRINT,    0,        0},
  161. {"printf",    Node_K_printf,     LEX_PRINTF,    0,        0},
  162. {"rand",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(0),    do_rand},
  163. {"return",    Node_K_return,     LEX_RETURN,    NOT_OLD,    0},
  164. {"sin",        Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_sin},
  165. {"split",    Node_builtin,     LEX_BUILTIN,    A(2)|A(3),    do_split},
  166. {"sprintf",    Node_builtin,     LEX_BUILTIN,    0,        do_sprintf},
  167. {"sqrt",    Node_builtin,     LEX_BUILTIN,    A(1),        do_sqrt},
  168. {"srand",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(0)|A(1), do_srand},
  169. {"strftime",    Node_builtin,     LEX_BUILTIN,    GAWKX|A(1)|A(2), do_strftime},
  170. {"sub",        Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(2)|A(3), do_sub},
  171. {"substr",    Node_builtin,     LEX_BUILTIN,    A(2)|A(3),    do_substr},
  172. {"system",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_system},
  173. {"systime",    Node_builtin,     LEX_BUILTIN,    GAWKX|A(0),    do_systime},
  174. {"tolower",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_tolower},
  175. {"toupper",    Node_builtin,     LEX_BUILTIN,    NOT_OLD|A(1),    do_toupper},
  176. {"while",    Node_K_while,     LEX_WHILE,    0,        0},
  177. };
  178.  
  179. /* VARARGS0 */
  180. static void
  181. yyerror(va_alist)
  182. va_dcl
  183. {
  184.     va_list args;
  185.     char *mesg;
  186.     register char *bp, *cp;
  187.     char *scan;
  188.     char buf[120];
  189.  
  190.     errcount++;
  191.     /* Find the current line in the input file */
  192.     if (lexptr) {
  193.         if (!thisline) {
  194.             for (cp=lexeme; cp != lexptr_begin && *cp != '\n'; --cp)
  195.                 ;
  196.             if (*cp == '\n')
  197.                 cp++;
  198.             thisline = cp;
  199.         }
  200.         /* NL isn't guaranteed */
  201.         bp = lexeme;
  202.         while (bp < lexend && *bp && *bp != '\n')
  203.             bp++;
  204.     } else {
  205.         thisline = "(END OF FILE)";
  206.         bp = thisline + 13;
  207.     }
  208.     msg("%.*s", (int) (bp - thisline), thisline);
  209.     bp = buf;
  210.     cp = buf + sizeof(buf) - 24;    /* 24 more than longest msg. input */
  211.     if (lexptr) {
  212.         scan = thisline;
  213.         while (bp < cp && scan < lexeme)
  214.             if (*scan++ == '\t')
  215.                 *bp++ = '\t';
  216.             else
  217.                 *bp++ = ' ';
  218.         *bp++ = '^';
  219.         *bp++ = ' ';
  220.     }
  221.     va_start(args);
  222.     mesg = va_arg(args, char *);
  223.     strcpy(bp, mesg);
  224.     err("", buf, args);
  225.     va_end(args);
  226.     exit(2);
  227. }
  228.  
  229. static char *
  230. get_src_buf()
  231. {
  232.     static int samefile = 0;
  233.     static int nextfile = 0;
  234.     static char *buf = NULL;
  235.     static int fd;
  236.     int n;
  237.     register char *scan;
  238.     static int len = 0;
  239.     static int did_newline = 0;
  240. #    define    SLOP    128    /* enough space to hold most source lines */
  241.  
  242.     if (cmdline_src) {
  243.         if (len == 0) {
  244.             len = strlen(cmdline_src);
  245.             if (len == 0)
  246.                 cmdline_src = NULL;
  247.             sourceline = 1;
  248.             lexptr = lexptr_begin = cmdline_src;
  249.             lexend = lexptr + len;
  250.         } else if (!did_newline && *(lexptr-1) != '\n') {
  251.             /*
  252.              * The following goop is to ensure that the source
  253.              * ends with a newline and that the entire current
  254.              * line is available for error messages.
  255.              */
  256.             int offset;
  257.  
  258.             did_newline = 1;
  259.             offset = lexptr - lexeme;
  260.             for (scan = lexeme; scan > lexptr_begin; scan--)
  261.                 if (*scan == '\n') {
  262.                     scan++;
  263.                     break;
  264.                 }
  265.             len = lexptr - scan;
  266.             emalloc(buf, char *, len+1, "get_src_buf");
  267.             memcpy(buf, scan, len);
  268.             thisline = buf;
  269.             lexptr = buf + len;
  270.             *lexptr = '\n';
  271.             lexeme = lexptr - offset;
  272.             lexptr_begin = buf;
  273.             lexend = lexptr + 1;
  274.         } else
  275.             lexeme = lexptr = lexptr_begin = NULL;
  276.         return lexptr;
  277.     }
  278.     if (!samefile) {
  279.         source = srcfiles[nextfile];
  280.         if (source == NULL) {
  281.             if (buf)
  282.                 free(buf);
  283.             return lexeme = lexptr = lexptr_begin = NULL;
  284.         }
  285.         fd = pathopen(source);
  286.         if (fd == -1)
  287.             fatal("can't open source file \"%s\" for reading (%s)",
  288.                 source, strerror(errno));
  289.         len = optimal_bufsize(fd);
  290.         if (buf)
  291.             free(buf);
  292.         emalloc(buf, char *, len + SLOP, "get_src_buf");
  293.         lexptr_begin = buf + SLOP;
  294.         samefile = 1;
  295.         sourceline = 1;
  296.     } else {
  297.         /*
  298.          * Here, we retain the current source line (up to length SLOP)
  299.          * in the beginning of the buffer that was overallocated above
  300.          */
  301.         int offset;
  302.         int linelen;
  303.  
  304.         offset = lexptr - lexeme;
  305.         for (scan = lexeme; scan > lexptr_begin; scan--)
  306.             if (*scan == '\n') {
  307.                 scan++;
  308.                 break;
  309.             }
  310.         linelen = lexptr - scan;
  311.         if (linelen > SLOP)
  312.             len = SLOP;
  313.         thisline = buf + SLOP - linelen;
  314.         memcpy(thisline, scan, linelen);
  315.         lexeme = buf + SLOP - offset;
  316.         lexptr_begin = thisline;
  317.     }
  318.     n = read(fd, buf + SLOP, len);
  319.     if (n == -1)
  320.         fatal("can't read sourcefile \"%s\" (%s)",
  321.             source, strerror(errno));
  322.     if (n == 0) {
  323.         samefile = 0;
  324.         nextfile++;
  325.         return get_src_buf();
  326.     }
  327.     lexptr = buf + SLOP;
  328.     lexend = lexptr + n;
  329.     return buf;
  330. }
  331.  
  332. #define    tokadd(x) (*token++ = (x), token == tokend ? tokexpand() : token)
  333.  
  334. char *
  335. tokexpand()
  336. {
  337.     static int toksize = 60;
  338.     int tokoffset;
  339.  
  340.     tokoffset = token - tokstart;
  341.     toksize *= 2;
  342.     if (tokstart)
  343.         erealloc(tokstart, char *, toksize, "tokexpand");
  344.     else
  345.         emalloc(tokstart, char *, toksize, "tokexpand");
  346.     tokend = tokstart + toksize;
  347.     token = tokstart + tokoffset;
  348.     return token;
  349. }
  350.  
  351. #ifdef DEBUG
  352. char
  353. nextc() {
  354.     if (lexptr && lexptr < lexend)
  355.         return *lexptr++;
  356.     if (get_src_buf())
  357.         return *lexptr++;
  358.     return '\0';
  359. }
  360. #else
  361. #define    nextc()    ((lexptr && lexptr < lexend) ? \
  362.             *lexptr++ : \
  363.             (get_src_buf() ? *lexptr++ : '\0') \
  364.         )
  365. #endif
  366. #define pushback() (lexptr && lexptr > lexptr_begin ? lexptr-- : lexptr)
  367.  
  368. /*
  369.  * Read the input and turn it into tokens.
  370.  */
  371.  
  372. static int
  373. yylex()
  374. {
  375.     register int c;
  376.     int seen_e = 0;        /* These are for numbers */
  377.     int seen_point = 0;
  378.     int esc_seen;        /* for literal strings */
  379.     int low, mid, high;
  380.     static int did_newline = 0;
  381.     char *tokkey;
  382.  
  383.     if (!nextc())
  384.         return 0;
  385.     pushback();
  386.     lexeme = lexptr;
  387.     thisline = NULL;
  388.     if (want_regexp) {
  389.         int in_brack = 0;
  390.  
  391.         want_regexp = 0;
  392.         token = tokstart;
  393.         while ((c = nextc()) != 0) {
  394.             switch (c) {
  395.             case '[':
  396.                 in_brack = 1;
  397.                 break;
  398.             case ']':
  399.                 in_brack = 0;
  400.                 break;
  401.             case '\\':
  402.                 if ((c = nextc()) == '\0') {
  403.                     yyerror("unterminated regexp ends with \\ at end of file");
  404.                 } else if (c == '\n') {
  405.                     sourceline++;
  406.                     continue;
  407.                 } else
  408.                     tokadd('\\');
  409.                 break;
  410.             case '/':    /* end of the regexp */
  411.                 if (in_brack)
  412.                     break;
  413.  
  414.                 pushback();
  415.                 tokadd('\0');
  416.                 yylval.sval = tokstart;
  417.                 return REGEXP;
  418.             case '\n':
  419.                 pushback();
  420.                 yyerror("unterminated regexp");
  421.             case '\0':
  422.                 yyerror("unterminated regexp at end of file");
  423.             }
  424.             tokadd(c);
  425.         }
  426.     }
  427. retry:
  428.     while ((c = nextc()) == ' ' || c == '\t')
  429.         ;
  430.  
  431.     lexeme = lexptr-1;
  432.     thisline = NULL;
  433.     token = tokstart;
  434.     yylval.nodetypeval = Node_illegal;
  435.  
  436.     switch (c) {
  437.     case 0:
  438.         return 0;
  439.  
  440.     case '\n':
  441.         sourceline++;
  442.         return NEWLINE;
  443.  
  444.     case '#':        /* it's a comment */
  445.         while ((c = nextc()) != '\n') {
  446.             if (c == '\0')
  447.                 return 0;
  448.         }
  449.         sourceline++;
  450.         return NEWLINE;
  451.  
  452.     case '\\':
  453. #ifdef RELAXED_CONTINUATION
  454.         if (!strict) {    /* strip trailing white-space and/or comment */
  455.             while ((c = nextc()) == ' ' || c == '\t') continue;
  456.             if (c == '#')
  457.                 while ((c = nextc()) != '\n') if (!c) break;
  458.             pushback();
  459.         }
  460. #endif /*RELAXED_CONTINUATION*/
  461.         if (nextc() == '\n') {
  462.             sourceline++;
  463.             goto retry;
  464.         } else
  465.             yyerror("inappropriate use of backslash");
  466.         break;
  467.  
  468.     case '$':
  469.         want_assign = 1;
  470.         return '$';
  471.  
  472.     case ')':
  473.     case ']':
  474.     case '(':    
  475.     case '[':
  476.     case ';':
  477.     case ':':
  478.     case '?':
  479.     case '{':
  480.     case ',':
  481.         return c;
  482.  
  483.     case '*':
  484.         if ((c = nextc()) == '=') {
  485.             yylval.nodetypeval = Node_assign_times;
  486.             return ASSIGNOP;
  487.         } else if (do_posix) {
  488.             pushback();
  489.             return '*';
  490.         } else if (c == '*') {
  491.             /* make ** and **= aliases for ^ and ^= */
  492.             static int did_warn_op = 0, did_warn_assgn = 0;
  493.  
  494.             if (nextc() == '=') {
  495.                 if (do_lint && ! did_warn_assgn) {
  496.                     did_warn_assgn = 1;
  497.                     warning("**= is not allowed by POSIX");
  498.                 }
  499.                 yylval.nodetypeval = Node_assign_exp;
  500.                 return ASSIGNOP;
  501.             } else {
  502.                 pushback();
  503.                 if (do_lint && ! did_warn_op) {
  504.                     did_warn_op = 1;
  505.                     warning("** is not allowed by POSIX");
  506.                 }
  507.                 return '^';
  508.             }
  509.         }
  510.         pushback();
  511.         return '*';
  512.  
  513.     case '/':
  514.         if (want_assign) {
  515.             if (nextc() == '=') {
  516.                 yylval.nodetypeval = Node_assign_quotient;
  517.                 return ASSIGNOP;
  518.             }
  519.             pushback();
  520.         }
  521.         return '/';
  522.  
  523.     case '%':
  524.         if (nextc() == '=') {
  525.             yylval.nodetypeval = Node_assign_mod;
  526.             return ASSIGNOP;
  527.         }
  528.         pushback();
  529.         return '%';
  530.  
  531.     case '^':
  532.     {
  533.         static int did_warn_op = 0, did_warn_assgn = 0;
  534.  
  535.         if (nextc() == '=') {
  536.  
  537.             if (do_lint && ! did_warn_assgn) {
  538.                 did_warn_assgn = 1;
  539.                 warning("operator `^=' is not supported in old awk");
  540.             }
  541.             yylval.nodetypeval = Node_assign_exp;
  542.             return ASSIGNOP;
  543.         }
  544.         pushback();
  545.         if (do_lint && ! did_warn_op) {
  546.             did_warn_op = 1;
  547.             warning("operator `^' is not supported in old awk");
  548.         }
  549.         return '^';
  550.     }
  551.  
  552.     case '+':
  553.         if ((c = nextc()) == '=') {
  554.             yylval.nodetypeval = Node_assign_plus;
  555.             return ASSIGNOP;
  556.         }
  557.         if (c == '+')
  558.             return INCREMENT;
  559.         pushback();
  560.         return '+';
  561.  
  562.     case '!':
  563.         if ((c = nextc()) == '=') {
  564.             yylval.nodetypeval = Node_notequal;
  565.             return RELOP;
  566.         }
  567.         if (c == '~') {
  568.             yylval.nodetypeval = Node_nomatch;
  569.             want_assign = 0;
  570.             return MATCHOP;
  571.         }
  572.         pushback();
  573.         return '!';
  574.  
  575.     case '<':
  576.         if (nextc() == '=') {
  577.             yylval.nodetypeval = Node_leq;
  578.             return RELOP;
  579.         }
  580.         yylval.nodetypeval = Node_less;
  581.         pushback();
  582.         return '<';
  583.  
  584.     case '=':
  585.         if (nextc() == '=') {
  586.             yylval.nodetypeval = Node_equal;
  587.             return RELOP;
  588.         }
  589.         yylval.nodetypeval = Node_assign;
  590.         pushback();
  591.         return ASSIGNOP;
  592.  
  593.     case '>':
  594.         if ((c = nextc()) == '=') {
  595.             yylval.nodetypeval = Node_geq;
  596.             return RELOP;
  597.         } else if (c == '>') {
  598.             yylval.nodetypeval = Node_redirect_append;
  599.             return APPEND_OP;
  600.         }
  601.         yylval.nodetypeval = Node_greater;
  602.         pushback();
  603.         return '>';
  604.  
  605.     case '~':
  606.         yylval.nodetypeval = Node_match;
  607.         want_assign = 0;
  608.         return MATCHOP;
  609.  
  610.     case '}':
  611.         /*
  612.          * Added did newline stuff.  Easier than
  613.          * hacking the grammar
  614.          */
  615.         if (did_newline) {
  616.             did_newline = 0;
  617.             return c;
  618.         }
  619.         did_newline++;
  620.         --lexptr;    /* pick up } next time */
  621.         return NEWLINE;
  622.  
  623.     case '"':
  624.         esc_seen = 0;
  625.         while ((c = nextc()) != '"') {
  626.             if (c == '\n') {
  627.                 pushback();
  628.                 yyerror("unterminated string");
  629.             }
  630.             if (c == '\\') {
  631.                 c = nextc();
  632.                 if (c == '\n') {
  633.                     sourceline++;
  634.                     continue;
  635.                 }
  636.                 esc_seen = 1;
  637.                 tokadd('\\');
  638.             }
  639.             if (c == '\0') {
  640.                 pushback();
  641.                 yyerror("unterminated string");
  642.             }
  643.             tokadd(c);
  644.         }
  645.         yylval.nodeval = make_str_node(tokstart,
  646.                     token - tokstart, esc_seen ? SCAN : 0);
  647.         yylval.nodeval->flags |= PERM;
  648.         return YSTRING;
  649.  
  650.     case '-':
  651.         if ((c = nextc()) == '=') {
  652.             yylval.nodetypeval = Node_assign_minus;
  653.             return ASSIGNOP;
  654.         }
  655.         if (c == '-')
  656.             return DECREMENT;
  657.         pushback();
  658.         return '-';
  659.  
  660.     case '.':
  661.         c = nextc();
  662.         pushback();
  663.         if (!isdigit(c))
  664.             return '.';
  665.         else
  666.             c = '.';    /* FALL THROUGH */
  667.     case '0':
  668.     case '1':
  669.     case '2':
  670.     case '3':
  671.     case '4':
  672.     case '5':
  673.     case '6':
  674.     case '7':
  675.     case '8':
  676.     case '9':
  677.         /* It's a number */
  678.         for (;;) {
  679.             int gotnumber = 0;
  680.  
  681.             tokadd(c);
  682.             switch (c) {
  683.             case '.':
  684.                 if (seen_point) {
  685.                     gotnumber++;
  686.                     break;
  687.                 }
  688.                 ++seen_point;
  689.                 break;
  690.             case 'e':
  691.             case 'E':
  692.                 if (seen_e) {
  693.                     gotnumber++;
  694.                     break;
  695.                 }
  696.                 ++seen_e;
  697.                 if ((c = nextc()) == '-' || c == '+')
  698.                     tokadd(c);
  699.                 else
  700.                     pushback();
  701.                 break;
  702.             case '0':
  703.             case '1':
  704.             case '2':
  705.             case '3':
  706.             case '4':
  707.             case '5':
  708.             case '6':
  709.             case '7':
  710.             case '8':
  711.             case '9':
  712.                 break;
  713.             default:
  714.                 gotnumber++;
  715.             }
  716.             if (gotnumber)
  717.                 break;
  718.             c = nextc();
  719.         }
  720.         pushback();
  721.         yylval.nodeval = make_number(atof(tokstart));
  722.         yylval.nodeval->flags |= PERM;
  723.         return YNUMBER;
  724.  
  725.     case '&':
  726.         if ((c = nextc()) == '&') {
  727.             yylval.nodetypeval = Node_and;
  728.             for (;;) {
  729.                 c = nextc();
  730.                 if (c == '\0')
  731.                     break;
  732.                 if (c == '#') {
  733.                     while ((c = nextc()) != '\n' && c != '\0')
  734.                         ;
  735.                     if (c == '\0')
  736.                         break;
  737.                 }
  738.                 if (c == '\n')
  739.                     sourceline++;
  740.                 if (! isspace(c)) {
  741.                     pushback();
  742.                     break;
  743.                 }
  744.             }
  745.             want_assign = 0;
  746.             return LEX_AND;
  747.         }
  748.         pushback();
  749.         return '&';
  750.  
  751.     case '|':
  752.         if ((c = nextc()) == '|') {
  753.             yylval.nodetypeval = Node_or;
  754.             for (;;) {
  755.                 c = nextc();
  756.                 if (c == '\0')
  757.                     break;
  758.                 if (c == '#') {
  759.                     while ((c = nextc()) != '\n' && c != '\0')
  760.                         ;
  761.                     if (c == '\0')
  762.                         break;
  763.                 }
  764.                 if (c == '\n')
  765.                     sourceline++;
  766.                 if (! isspace(c)) {
  767.                     pushback();
  768.                     break;
  769.                 }
  770.             }
  771.             want_assign = 0;
  772.             return LEX_OR;
  773.         }
  774.         pushback();
  775.         return '|';
  776.     }
  777.  
  778.     if (c != '_' && ! isalpha(c))
  779.         yyerror("Invalid char '%c' in expression\n", c);
  780.  
  781.     /* it's some type of name-type-thing.  Find its length */
  782.     token = tokstart;
  783.     while (is_identchar(c)) {
  784.         tokadd(c);
  785.         c = nextc();
  786.     }
  787.     tokadd('\0');
  788.     emalloc(tokkey, char *, token - tokstart, "yylex");
  789.     memcpy(tokkey, tokstart, token - tokstart);
  790.     pushback();
  791.  
  792.     /* See if it is a special token.  */
  793.     low = 0;
  794.     high = (sizeof (tokentab) / sizeof (tokentab[0])) - 1;
  795.     while (low <= high) {
  796.         int i/* , c */;
  797.  
  798.         mid = (low + high) / 2;
  799.         c = *tokstart - tokentab[mid].operator[0];
  800.         i = c ? c : strcmp (tokstart, tokentab[mid].operator);
  801.  
  802.         if (i < 0) {        /* token < mid */
  803.             high = mid - 1;
  804.         } else if (i > 0) {    /* token > mid */
  805.             low = mid + 1;
  806.         } else {
  807.             if (do_lint) {
  808.                 if (tokentab[mid].flags & GAWKX)
  809.                     warning("%s() is a gawk extension",
  810.                         tokentab[mid].operator);
  811.                 if (tokentab[mid].flags & NOT_POSIX)
  812.                     warning("POSIX does not allow %s",
  813.                         tokentab[mid].operator);
  814.                 if (tokentab[mid].flags & NOT_OLD)
  815.                     warning("%s is not supported in old awk",
  816.                         tokentab[mid].operator);
  817.             }
  818.             if ((strict && (tokentab[mid].flags & GAWKX))
  819.                 || (do_posix && (tokentab[mid].flags & NOT_POSIX)))
  820.                 break;
  821.             if (tokentab[mid].class == LEX_BUILTIN
  822.                 || tokentab[mid].class == LEX_LENGTH
  823.                )
  824.                 yylval.lval = mid;
  825.             else
  826.                 yylval.nodetypeval = tokentab[mid].value;
  827.  
  828.             return tokentab[mid].class;
  829.         }
  830.     }
  831.  
  832.     yylval.sval = tokkey;
  833.     if (*lexptr == '(')
  834.         return FUNC_CALL;
  835.     else {
  836.         want_assign = 1;
  837.         return NAME;
  838.     }
  839. }
  840.  
  841. static NODE *
  842. node_common(op)
  843. NODETYPE op;
  844. {
  845.     register NODE *r;
  846.  
  847.     getnode(r);
  848.     r->type = op;
  849.     r->flags = MALLOC;
  850.     /* if lookahead is NL, lineno is 1 too high */
  851.     if (lexeme && *lexeme == '\n')
  852.         r->source_line = sourceline - 1;
  853.     else
  854.         r->source_line = sourceline;
  855.     r->source_file = source;
  856.     return r;
  857. }
  858.  
  859. /*
  860.  * This allocates a node with defined lnode and rnode. 
  861.  */
  862. NODE *
  863. node(left, op, right)
  864. NODE *left, *right;
  865. NODETYPE op;
  866. {
  867.     register NODE *r;
  868.  
  869.     r = node_common(op);
  870.     r->lnode = left;
  871.     r->rnode = right;
  872.     return r;
  873. }
  874.  
  875. /*
  876.  * This allocates a node with defined subnode and proc for builtin functions
  877.  * Checks for arg. count and supplies defaults where possible.
  878.  */
  879. static NODE *
  880. snode(subn, op, idx)
  881. NODETYPE op;
  882. int idx;
  883. NODE *subn;
  884. {
  885.     register NODE *r;
  886.     register NODE *n;
  887.     int nexp = 0;
  888.     int args_allowed;
  889.  
  890.     r = node_common(op);
  891.  
  892.     /* traverse expression list to see how many args. given */
  893.     for (n= subn; n; n= n->rnode) {
  894.         nexp++;
  895.         if (nexp > 3)
  896.             break;
  897.     }
  898.  
  899.     /* check against how many args. are allowed for this builtin */
  900.     args_allowed = tokentab[idx].flags & ARGS;
  901.     if (args_allowed && !(args_allowed & A(nexp)))
  902.         fatal("%s() cannot have %d argument%c",
  903.             tokentab[idx].operator, nexp, nexp == 1 ? ' ' : 's');
  904.  
  905.     r->proc = tokentab[idx].ptr;
  906.  
  907.     /* special case processing for a few builtins */
  908.     if (nexp == 0 && r->proc == do_length) {
  909.         subn = node(node(make_number(0.0),Node_field_spec,(NODE *)NULL),
  910.                     Node_expression_list,
  911.                 (NODE *) NULL);
  912.     } else if (r->proc == do_match) {
  913.         if (subn->rnode->lnode->type != Node_regex)
  914.             subn->rnode->lnode = mk_rexp(subn->rnode->lnode);
  915.     } else if (r->proc == do_sub || r->proc == do_gsub) {
  916.         if (subn->lnode->type != Node_regex)
  917.             subn->lnode = mk_rexp(subn->lnode);
  918.         if (nexp == 2)
  919.             append_right(subn, node(node(make_number(0.0),
  920.                              Node_field_spec,
  921.                              (NODE *) NULL),
  922.                             Node_expression_list,
  923.                         (NODE *) NULL));
  924.         else if (do_lint && subn->rnode->rnode->lnode->type == Node_val)
  925.             warning("string literal as last arg of substitute");
  926.     } else if (r->proc == do_split) {
  927.         if (nexp == 2)
  928.             append_right(subn,
  929.                 node(FS_node, Node_expression_list, (NODE *) NULL));
  930.         n = subn->rnode->rnode->lnode;
  931.         if (n->type != Node_regex)
  932.             subn->rnode->rnode->lnode = mk_rexp(n);
  933.         if (nexp == 2)
  934.             subn->rnode->rnode->lnode->re_flags |= FS_DFLT;
  935.     }
  936.  
  937.     r->subnode = subn;
  938.     return r;
  939. }
  940.  
  941. /*
  942.  * This allocates a Node_line_range node with defined condpair and
  943.  * zeroes the trigger word to avoid the temptation of assuming that calling
  944.  * 'node( foo, Node_line_range, 0)' will properly initialize 'triggered'. 
  945.  */
  946. /* Otherwise like node() */
  947. static NODE *
  948. mkrangenode(cpair)
  949. NODE *cpair;
  950. {
  951.     register NODE *r;
  952.  
  953.     getnode(r);
  954.     r->type = Node_line_range;
  955.     r->condpair = cpair;
  956.     r->triggered = 0;
  957.     return r;
  958. }
  959.  
  960. /* Build a for loop */
  961. static NODE *
  962. make_for_loop(init, cond, incr)
  963. NODE *init, *cond, *incr;
  964. {
  965.     register FOR_LOOP_HEADER *r;
  966.     NODE *n;
  967.  
  968.     emalloc(r, FOR_LOOP_HEADER *, sizeof(FOR_LOOP_HEADER), "make_for_loop");
  969.     getnode(n);
  970.     n->type = Node_illegal;
  971.     r->init = init;
  972.     r->cond = cond;
  973.     r->incr = incr;
  974.     n->sub.nodep.r.hd = r;
  975.     return n;
  976. }
  977.  
  978. /*
  979.  * Install a name in the symbol table, even if it is already there.
  980.  * Caller must check against redefinition if that is desired. 
  981.  */
  982. NODE *
  983. install(name, value)
  984. char *name;
  985. NODE *value;
  986. {
  987.     register NODE *hp;
  988.     register int len, bucket;
  989.  
  990.     len = strlen(name);
  991.     bucket = hash(name, len);
  992.     getnode(hp);
  993.     hp->type = Node_hashnode;
  994.     hp->hnext = variables[bucket];
  995.     variables[bucket] = hp;
  996.     hp->hlength = len;
  997.     hp->hvalue = value;
  998.     hp->hname = name;
  999.     return hp->hvalue;
  1000. }
  1001.  
  1002. /* find the most recent hash node for name installed by install */
  1003. NODE *
  1004. lookup(name)
  1005. char *name;
  1006. {
  1007.     register NODE *bucket;
  1008.     register int len;
  1009.  
  1010.     len = strlen(name);
  1011.     bucket = variables[hash(name, len)];
  1012.     while (bucket) {
  1013.         if (bucket->hlength == len && STREQN(bucket->hname, name, len))
  1014.             return bucket->hvalue;
  1015.         bucket = bucket->hnext;
  1016.     }
  1017.     return NULL;
  1018. }
  1019.  
  1020. /*
  1021.  * Add new to the rightmost branch of LIST.  This uses n^2 time, so we make
  1022.  * a simple attempt at optimizing it.
  1023.  */
  1024. static NODE *
  1025. append_right(list, new)
  1026. NODE *list, *new;
  1027. {
  1028.     register NODE *oldlist;
  1029.     static NODE *savefront = NULL, *savetail = NULL;
  1030.  
  1031.     oldlist = list;
  1032.     if (savefront == oldlist) {
  1033.         savetail = savetail->rnode = new;
  1034.         return oldlist;
  1035.     } else
  1036.         savefront = oldlist;
  1037.     while (list->rnode != NULL)
  1038.         list = list->rnode;
  1039.     savetail = list->rnode = new;
  1040.     return oldlist;
  1041. }
  1042.  
  1043. /*
  1044.  * check if name is already installed;  if so, it had better have Null value,
  1045.  * in which case def is added as the value. Otherwise, install name with def
  1046.  * as value. 
  1047.  */
  1048. static void
  1049. func_install(params, def)
  1050. NODE *params;
  1051. NODE *def;
  1052. {
  1053.     NODE *r;
  1054.  
  1055.     pop_params(params->rnode);
  1056.     pop_var(params, 0);
  1057.     r = lookup(params->param);
  1058.     if (r != NULL) {
  1059.         fatal("function name `%s' previously defined", params->param);
  1060.     } else
  1061.         (void) install(params->param, node(params, Node_func, def));
  1062. }
  1063.  
  1064. static void
  1065. pop_var(np, freeit)
  1066. NODE *np;
  1067. int freeit;
  1068. {
  1069.     register NODE *bucket, **save;
  1070.     register int len;
  1071.     char *name;
  1072.  
  1073.     name = np->param;
  1074.     len = strlen(name);
  1075.     save = &(variables[hash(name, len)]);
  1076.     for (bucket = *save; bucket; bucket = bucket->hnext) {
  1077.         if (len == bucket->hlength && STREQN(bucket->hname, name, len)) {
  1078.             *save = bucket->hnext;
  1079.             freenode(bucket);
  1080.             if (freeit)
  1081.                 free(np->param);
  1082.             return;
  1083.         }
  1084.         save = &(bucket->hnext);
  1085.     }
  1086. }
  1087.  
  1088. static void
  1089. pop_params(params)
  1090. NODE *params;
  1091. {
  1092.     register NODE *np;
  1093.  
  1094.     for (np = params; np != NULL; np = np->rnode)
  1095.         pop_var(np, 1);
  1096. }
  1097.  
  1098. static NODE *
  1099. make_param(name)
  1100. char *name;
  1101. {
  1102.     NODE *r;
  1103.  
  1104.     getnode(r);
  1105.     r->type = Node_param_list;
  1106.     r->rnode = NULL;
  1107.     r->param = name;
  1108.     r->param_cnt = param_counter++;
  1109.     return (install(name, r));
  1110. }
  1111.  
  1112. /* Name points to a variable name.  Make sure its in the symbol table */
  1113. NODE *
  1114. variable(name, can_free)
  1115. char *name;
  1116. int can_free;
  1117. {
  1118.     register NODE *r;
  1119.     static int env_loaded = 0;
  1120.  
  1121.     if (!env_loaded && STREQ(name, "ENVIRON")) {
  1122.         load_environ();
  1123.         env_loaded = 1;
  1124.     }
  1125.     if ((r = lookup(name)) == NULL)
  1126.         r = install(name, node(Nnull_string, Node_var, (NODE *) NULL));
  1127.     else if (can_free)
  1128.         free(name);
  1129.     return r;
  1130. }
  1131.  
  1132. static NODE *
  1133. mk_rexp(exp)
  1134. NODE *exp;
  1135. {
  1136.     if (exp->type == Node_regex)
  1137.         return exp;
  1138.     else {
  1139.         NODE *n;
  1140.  
  1141.         getnode(n);
  1142.         n->type = Node_regex;
  1143.         n->re_exp = exp;
  1144.         n->re_text = NULL;
  1145.         n->re_reg = NULL;
  1146.         n->re_flags = 0;
  1147.         n->re_cnt = 1;
  1148.         return n;
  1149.     }
  1150. }
  1151. int yyexca[] ={
  1152. -1, 1,
  1153.     0, -1,
  1154.     -2, 0,
  1155. -1, 5,
  1156.     0, 61,
  1157.     -2, 0,
  1158. -1, 77,
  1159.     264, 78,
  1160.     267, 78,
  1161.     62, 78,
  1162.     124, 78,
  1163.     59, 78,
  1164.     -2, 0,
  1165. -1, 112,
  1166.     41, 86,
  1167.     -2, 0,
  1168. -1, 113,
  1169.     41, 86,
  1170.     -2, 0,
  1171. -1, 126,
  1172.     266, 0,
  1173.     -2, 101,
  1174. -1, 128,
  1175.     263, 0,
  1176.     60, 0,
  1177.     62, 0,
  1178.     124, 0,
  1179.     -2, 105,
  1180. -1, 129,
  1181.     263, 0,
  1182.     60, 0,
  1183.     62, 0,
  1184.     124, 0,
  1185.     -2, 106,
  1186. -1, 130,
  1187.     263, 0,
  1188.     60, 0,
  1189.     62, 0,
  1190.     124, 0,
  1191.     -2, 107,
  1192. -1, 149,
  1193.     264, 79,
  1194.     267, 79,
  1195.     62, 79,
  1196.     124, 79,
  1197.     59, 79,
  1198.     -2, 0,
  1199. -1, 188,
  1200.     41, 86,
  1201.     -2, 0,
  1202. -1, 190,
  1203.     41, 87,
  1204.     -2, 0,
  1205. -1, 224,
  1206.     41, 69,
  1207.     -2, 0,
  1208. -1, 253,
  1209.     266, 0,
  1210.     -2, 118,
  1211. -1, 255,
  1212.     263, 0,
  1213.     -2, 120,
  1214. -1, 263,
  1215.     41, 70,
  1216.     -2, 0,
  1217.     };
  1218. # define YYNPROD 161
  1219. # define YYLAST 1998
  1220. int yyact[]={
  1221.  
  1222.     62,   216,   107,    13,    87,   229,    13,    88,    89,   166,
  1223.    165,   123,   240,   297,     4,    82,    45,    37,    91,    45,
  1224.    292,   265,   291,   264,   204,    88,    89,   187,    88,    89,
  1225.    270,    24,   171,   266,   254,   155,    63,   161,    24,   127,
  1226.    176,    65,    98,   168,   169,    36,    52,    35,   157,    25,
  1227.     63,   174,    82,   122,    63,   124,   125,   126,    22,   128,
  1228.    129,   130,   131,    93,   136,    82,   189,   203,    66,    63,
  1229.    100,    82,   103,   222,   107,    64,   177,   101,    63,   158,
  1230.    158,    45,   102,    22,   103,   276,   206,    63,   232,   101,
  1231.    104,   174,   105,   269,   102,   224,   188,   163,    16,   178,
  1232.    144,   142,   113,   112,     6,    11,   133,    26,   186,   111,
  1233.     39,   257,   140,   186,   186,   170,    48,    94,   231,    99,
  1234.    160,   110,    82,   109,    86,    46,    41,   121,   159,   100,
  1235.    114,   115,   108,   134,    99,    99,   167,   164,    77,   262,
  1236.     71,   100,    82,   198,    82,   158,   141,   118,    91,   148,
  1237.    149,   263,   120,    10,    27,    20,     5,     1,    24,    50,
  1238.     12,   158,    17,   192,   223,    36,     0,    35,     0,    25,
  1239.      0,   225,   226,   228,     0,     0,   152,     0,     0,     0,
  1240.    191,    45,   207,   197,     0,     0,     0,   193,     0,   186,
  1241.    134,     0,     0,   201,     0,   237,    99,   241,   195,    99,
  1242.     99,    99,    99,    99,    99,   245,   246,   247,     0,   221,
  1243.    134,     0,   199,     0,     0,     0,   190,   217,     0,     0,
  1244.      0,     0,    94,   186,     4,    20,   205,     4,    24,     0,
  1245.      0,     0,    17,     0,    90,    36,     0,    35,     0,    25,
  1246.      0,     0,     0,   271,     0,    22,     0,    68,   172,   152,
  1247.      0,    45,    94,    23,    99,   233,     0,   236,   258,    30,
  1248.     23,     0,   280,    33,    34,   213,   172,     0,   211,    82,
  1249.    282,     0,    20,   158,     0,    24,    99,     0,    82,    17,
  1250.      0,   172,    36,     0,    35,   158,    25,   153,   212,   209,
  1251.    172,    31,    32,    28,    29,    82,   279,     0,    45,   208,
  1252.      0,     0,    82,    82,    82,     0,   152,   152,   152,   152,
  1253.    152,   273,   152,   152,   152,    22,    20,    68,     0,    24,
  1254.      0,   285,   155,    17,   185,    24,    36,     0,    35,    98,
  1255.     25,     0,    36,   295,    35,     0,    25,   281,     0,     0,
  1256.      0,     0,    45,     0,     0,     0,   289,   152,     0,   152,
  1257.    152,   152,   152,     0,   152,   152,   152,     0,     0,     0,
  1258.      0,     0,    22,   299,   202,     0,     0,     0,     0,     0,
  1259.    304,   305,   306,   152,   152,     0,     0,     0,   135,    30,
  1260.     23,     0,     0,    33,    34,     0,   152,     0,     0,     0,
  1261.      0,     0,     0,    83,     0,    80,    81,    72,    73,    74,
  1262.     75,    76,    84,    85,    78,    79,    22,    18,     0,     0,
  1263.      0,    31,    32,    28,    29,    20,     0,     0,    24,     0,
  1264.    215,     0,    17,     0,     0,    36,     0,    35,     0,    25,
  1265.      0,     0,     0,     0,     0,     0,     0,     0,     0,   260,
  1266.      0,    45,    59,     0,    60,    61,     0,     0,    67,    30,
  1267.     23,     0,     0,    33,    34,     0,     0,     0,     0,     0,
  1268.      0,     0,     0,    83,     0,    80,    81,    72,    73,    74,
  1269.     75,    76,    84,    85,    78,    79,     0,    18,     0,     0,
  1270.      0,    31,    32,    28,    29,     0,     0,     0,     0,     0,
  1271.      0,     0,     0,     0,     0,    67,    30,    23,   150,     0,
  1272.     33,    34,    21,     0,     0,     0,    53,     0,     0,     0,
  1273.     83,     0,    80,    81,    72,    73,    74,    75,    76,    84,
  1274.     85,    78,    79,    96,    18,     0,     0,     0,    31,    32,
  1275.     28,    29,     0,     0,     0,     0,     0,     0,   116,   117,
  1276.     30,    23,     0,     0,    33,    34,     2,    23,     0,     0,
  1277.     33,    34,    38,     0,    83,     0,    80,    81,    72,    73,
  1278.     74,    75,    76,    84,    85,    78,    79,     0,    18,   106,
  1279.      0,     0,    31,    32,    28,    29,     0,     0,    31,    32,
  1280.    156,     0,     0,     0,     0,    20,     0,     0,    24,     0,
  1281.      0,   119,    17,     0,     0,    36,     0,    35,     0,    25,
  1282.     96,     0,     0,   179,   180,   181,   182,   183,   184,     0,
  1283.    132,     0,    59,     0,    60,   138,   139,     0,     0,     0,
  1284.    143,     0,     0,     0,     0,     0,     0,     0,   248,   250,
  1285.    251,   252,   253,     0,   255,   256,     0,     0,     0,    30,
  1286.     23,     0,     0,    33,    34,    58,     0,     0,    56,     4,
  1287.      0,     0,    20,   156,     0,    24,     0,     0,    96,    17,
  1288.    174,     0,    36,     0,    35,     0,    25,    18,    57,    54,
  1289.     55,    31,    32,    28,    29,     0,    53,     0,   275,    59,
  1290.    230,    60,    61,   196,     0,     0,    70,     0,     0,    14,
  1291.      0,     0,    14,    20,     0,   287,    24,    14,     0,    51,
  1292.     17,     0,     0,    36,     0,    35,     0,    25,     0,     0,
  1293.    156,   156,   156,   156,   156,     0,   156,   156,   156,    45,
  1294.     59,     0,    60,    61,     0,     0,     0,     0,    14,     0,
  1295.      0,     0,     0,    14,     0,     0,     0,     0,    20,     0,
  1296.      0,    24,   238,    53,     0,    17,     0,     0,    36,     0,
  1297.     35,   156,    25,   156,   156,   156,   156,     0,   156,   156,
  1298.    156,     0,     0,   194,     0,    59,     0,    60,    61,     0,
  1299.      0,     0,     0,     0,     0,     0,     0,   156,   156,     0,
  1300.      0,     0,    20,     0,    53,    24,   268,     0,     0,    17,
  1301.    156,     0,    36,    63,    35,     0,    25,     0,     0,     0,
  1302.      0,     0,     0,     0,     0,     0,     0,     0,   277,    59,
  1303.     23,    60,    61,    33,    34,    58,     0,     0,     0,     0,
  1304.      0,    20,     0,     0,    24,   290,     0,     0,    17,    53,
  1305.    294,    36,     0,    35,     0,    25,     0,     0,     0,     0,
  1306.    298,    31,    32,   301,   302,     0,     0,   303,    59,     0,
  1307.     60,    61,     0,     0,     0,     0,     0,     0,   155,     0,
  1308.      0,    24,     0,     0,     0,    98,     0,     0,    36,     0,
  1309.     35,     0,    25,    53,     0,     0,    30,    23,     0,     0,
  1310.     33,    34,    58,   274,     0,    56,     0,     0,   214,     0,
  1311.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1312.      0,     0,     0,     0,    18,    57,    54,    55,    31,    32,
  1313.     28,    29,    53,     0,     0,     0,     0,    30,    23,     0,
  1314.      0,    33,    34,    58,     0,     0,    56,    20,     0,     0,
  1315.     24,     0,     0,     0,    17,     0,     0,    36,     0,    35,
  1316.      0,    25,     0,     0,     0,    18,    57,    54,    55,    31,
  1317.     32,    28,    29,     0,    59,     0,    60,     0,     0,     0,
  1318.      0,     0,    30,    23,     0,     0,    33,    34,    58,   155,
  1319.      0,    56,    24,     0,     0,   155,    98,     0,    24,    36,
  1320.      0,    35,    98,    25,     0,    36,     0,    35,     0,    25,
  1321.     18,    57,    54,    55,    31,    32,    28,    29,     0,   214,
  1322.      0,     0,     0,    19,     0,     0,    30,    23,     0,     0,
  1323.     33,    34,    58,    20,     0,    56,    24,     0,    53,     0,
  1324.     17,     0,     0,    36,    95,    35,     0,    25,     0,     0,
  1325.      0,     0,     0,     0,    18,    57,    54,    55,    31,    32,
  1326.     28,    29,     0,     0,     0,    30,    23,     0,     0,    33,
  1327.     34,    58,    20,     0,    56,    24,     0,     0,     0,    17,
  1328.      0,     0,    36,     0,    35,     0,    25,     0,     0,     0,
  1329.      0,     0,     0,    18,    57,    54,    55,    31,    32,    28,
  1330.     29,   154,    30,    23,     0,     0,    33,    34,   213,     0,
  1331.      0,   211,     0,     0,     0,     0,     0,     0,     0,     0,
  1332.      0,     0,     0,    22,     0,     0,     0,     0,     0,     0,
  1333.    153,   212,   209,   210,    31,    32,    28,    29,    20,     0,
  1334.      0,    24,     0,     0,     0,    17,     0,     0,    36,     0,
  1335.     35,     0,    25,     0,   155,     0,     0,    24,     0,     0,
  1336.      0,    98,    22,     0,    36,    59,    35,    60,    25,     0,
  1337.      0,    30,    23,     0,   154,    33,    34,    58,     0,   218,
  1338.     56,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1339.      0,     0,     0,     0,     0,     0,     0,     0,     0,    18,
  1340.     57,    54,     0,    31,    32,    28,    29,     0,     0,     0,
  1341.      0,     0,     0,    30,    23,     0,     0,    33,    34,   213,
  1342.     23,     0,   211,    33,    34,   213,     0,     0,     0,    53,
  1343.      0,   154,   154,   154,   154,   154,     0,   154,   154,   154,
  1344.      0,   153,   212,   209,   210,    31,    32,    28,    29,     0,
  1345.      0,    31,    32,     0,     0,     0,    40,    30,    23,     0,
  1346.      0,    33,    34,     0,     0,     0,     0,     4,     0,     8,
  1347.      9,     0,   154,     0,   154,   154,   154,   154,     0,   154,
  1348.    154,   154,     0,     0,    15,    18,     0,     0,     0,    31,
  1349.     32,    28,    29,     0,     0,     7,    30,    23,   154,   154,
  1350.     33,    34,     0,     0,     0,     0,     0,    20,     8,     9,
  1351.     24,   154,     0,     0,    17,     0,     0,    36,     0,    35,
  1352.      0,    25,     0,    15,    18,     0,     0,     0,    31,    32,
  1353.     28,    29,    20,    45,     0,    24,     0,     0,     0,    17,
  1354.      0,     0,    36,     0,    35,   155,    25,     0,    24,     0,
  1355.      0,     0,    98,     0,     0,    36,     0,    35,     0,    25,
  1356.      0,     0,    30,    23,     0,     0,    33,    34,    58,     0,
  1357.      0,    56,     0,     0,     0,     0,     0,     0,    30,    23,
  1358.      0,     0,    33,    34,   213,     0,     0,   211,     0,     0,
  1359.     18,    57,     0,     0,    31,    32,    28,    29,     0,     0,
  1360.      0,     0,     0,     0,     0,     0,   153,   212,     0,     0,
  1361.     31,    32,    28,    29,    20,     0,     0,    24,     0,     0,
  1362.    175,    17,   155,     0,    36,    24,    35,     0,    25,   147,
  1363.      0,     0,    36,     0,    35,     0,    25,     0,     0,     0,
  1364.     20,     0,     0,    24,     0,     0,     0,    17,     0,     0,
  1365.     36,     0,    35,     0,    25,     0,     0,     0,     0,     0,
  1366.      0,   155,     0,     0,    24,     0,     0,     0,    98,     0,
  1367.      0,    36,     0,    35,     0,    25,    20,     0,     0,    24,
  1368.      0,     0,     0,    17,     0,     0,    36,     0,    35,     0,
  1369.     25,     0,     0,     0,     0,     0,     0,     0,    97,     0,
  1370.      0,    24,     0,     0,     0,    98,     0,     0,    36,     0,
  1371.     35,   173,    25,    97,     0,     0,    24,     0,     0,     0,
  1372.     98,     0,     0,    36,     0,    35,     0,     0,     0,     0,
  1373.      0,    30,    23,     0,    20,    33,    34,    24,     0,     0,
  1374.      0,    17,     0,     0,    36,     0,    35,     0,    25,     0,
  1375.      0,     0,     0,     0,     0,    92,    30,    23,     0,    18,
  1376.     33,    34,     0,    31,    32,    28,    29,     0,   249,    30,
  1377.     23,     0,     0,    33,    34,     0,     0,     0,     0,     0,
  1378.      0,     0,     0,     0,    18,     0,     0,     0,    31,    32,
  1379.     28,    29,     0,     0,     0,     0,     0,   153,     0,     0,
  1380.      0,    31,    32,    28,    29,     0,     0,     0,     0,     0,
  1381.    234,     0,   235,     0,     0,     0,     0,     0,     0,   239,
  1382.      0,     0,     0,   243,     0,     0,     0,     0,     0,     0,
  1383.      0,     0,     0,     0,     0,     0,     0,   227,    30,    23,
  1384.      0,     0,    33,    34,   261,   151,    30,    23,    69,     0,
  1385.     33,    34,     0,     0,   267,     0,     0,    44,    44,    44,
  1386.      0,     0,     0,     0,    30,    23,    18,     0,    33,    34,
  1387.     31,    32,    28,    29,   153,     0,     0,     0,    31,    32,
  1388.     28,    29,     0,   278,     3,    30,    23,     0,     0,    33,
  1389.     34,   283,    18,    43,    43,    43,    31,    32,    28,    29,
  1390.     30,   200,     0,   293,    33,    34,   296,     0,     0,     0,
  1391.      0,     0,     0,   153,   137,     0,   300,    31,    32,    28,
  1392.     29,     0,    30,    23,    44,    44,    33,    34,    18,     0,
  1393.      0,    44,    31,    32,    28,    29,     0,    30,    23,     0,
  1394.     42,    33,    34,     0,     0,     0,     0,     0,     0,     0,
  1395.     47,    49,     0,     0,    31,    32,    28,    29,     0,    23,
  1396.     43,    43,    33,    34,     0,     0,     0,    43,     0,    31,
  1397.     32,    28,    29,     0,     0,     0,     0,     0,     0,     0,
  1398.      0,     0,   137,     0,     0,     0,     0,     0,     0,     0,
  1399.     31,    32,     0,     0,     0,     0,     0,     0,     0,     0,
  1400.      0,     0,     0,     0,     0,     0,    44,     0,    44,     0,
  1401.      0,     0,     0,     0,     0,     0,   145,   146,     0,     0,
  1402.      0,     0,     0,   162,     0,     0,     0,     0,     0,     0,
  1403.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1404.      0,   137,    43,     0,    43,     0,     0,     0,     0,     0,
  1405.    242,     0,    44,     0,     0,     0,     0,     0,     0,     0,
  1406.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1407.     44,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1408.      0,     0,     0,     0,     0,     0,     0,     0,    43,     0,
  1409.      0,   272,     0,     0,     0,     0,     0,     0,   219,     0,
  1410.    220,     0,     0,     0,     0,     0,    43,     0,     0,     0,
  1411.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1412.    284,     0,    44,     0,     0,    44,     0,     0,     0,     0,
  1413.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1414.      0,     0,     0,     0,   244,     0,     0,     0,     0,     0,
  1415.      0,     0,     0,     0,     0,     0,     0,     0,    43,     0,
  1416.      0,    43,   259,     0,     0,     0,     0,     0,     0,     0,
  1417.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1418.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1419.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1420.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1421.      0,     0,     0,     0,   286,     0,     0,   288 };
  1422. int yypact[]={
  1423.  
  1424.   -253, -1000,  1019,  -250, -1000,   980, -1000, -1000,   -43,   -43,
  1425.    -40, -1000,   -65,   749,   192, -1000,  -261,  1279,    -5, -1000,
  1426.   1445,    47,  -253,   -17,  1460, -1000, -1000, -1000, -1000,    63,
  1427.     62,    -5,    -5, -1000, -1000,  1460,  1460, -1000, -1000, -1000,
  1428.  -1000,   -65, -1000,  -250,  -253, -1000,   -65, -1000, -1000, -1000,
  1429.  -1000,   239,  1387,  -274,  1387,  1387,  1387,  -219,  1387,  1387,
  1430.   1387,  1387,  1481,  -253,   122,    22, -1000, -1000,  -253,  -253,
  1431.    192, -1000,    61,  -253,    60,   -43,   -43,  1369,  1387,  1387,
  1432.  -1000,  -221,   382,    57, -1000, -1000,  -248, -1000, -1000, -1000,
  1433.     10,   619, -1000,    16, -1000, -1000,   -24,  1460,  1387,  -282,
  1434.   1460,  1460,  1460,  1460,  1460,  1460, -1000,  1279, -1000, -1000,
  1435.   -232,    56,  1279,  1279, -1000, -1000,   -24,   -24, -1000, -1000,
  1436.  -1000,   122,   788,    -5,  1085,   894,   552, -1000,  1481,  1481,
  1437.   1481,   705, -1000,    22, -1000, -1000,  -253, -1000, -1000, -1000,
  1438.  -1000,   122,  1387,   283,  1423, -1000, -1000,  1279,   -38,    43,
  1439.    936, -1000,  -264,    -5, -1000,  1445,    47,   -43,   788,   -43,
  1440.   1387,   -18, -1000,  1387,    55, -1000, -1000, -1000, -1000, -1000,
  1441.   1387,  1361,  1387,  -281, -1000, -1000, -1000,  1460,   619,   -24,
  1442.    -24,   -24,   -24,    35,    35,    25,   788,    41,  1279,    50,
  1443.     34,    50,    22, -1000,  1387,  -253, -1000, -1000,   619,  -263,
  1444.    -89,    22,    10,   -43,  1387,  1387,  1387,  1292,  1408,  1408,
  1445.   1408,  1408,  -224,  1408,  1408,   289, -1000,    16, -1000, -1000,
  1446.  -1000,   -43,  1279,   619,  -235,   788,   788, -1000,   788,  -225,
  1447.     47, -1000, -1000,    50, -1000, -1000, -1000,   788, -1000,  -253,
  1448.     53,  -228,  1254,   -38, -1000,   788,   788,   788,   936, -1000,
  1449.    936,  1101,     2,   942, -1000,   289,   825,  1408, -1000, -1000,
  1450.     -8,  -253,    50,     6, -1000, -1000, -1000, -1000,   283,  1387,
  1451.     50,   660,  1387,   -43,  1408,   936,   -43,   283,  -253,  -236,
  1452.  -1000, -1000,   619,  -253,  1387,    50, -1000,   936, -1000,  -259,
  1453.  -1000, -1000, -1000,  -253,   283,    50,  -253,  -253, -1000, -1000,
  1454.   -253,   283,   283,   283, -1000, -1000, -1000 };
  1455. int yypgo[]={
  1456.  
  1457.      0,   160,   159,   420,     0,   157,   156,   104,   502,   107,
  1458.    154,   153,   105,    98,   151,   150,   149,   216,    66,    75,
  1459.     68,   140,   139,    48,    63,  1003,    40,    67,   138,   137,
  1460.    136,   546,   126,   125,  1720,   124,  1400,   686,    41,    64,
  1461.     32,   121,  1664,  1628,   120,   115,   111,   109 };
  1462. int yyr1[]={
  1463.  
  1464.      0,     5,     6,     6,     6,     6,    32,     7,    33,     7,
  1465.      7,     7,     7,     7,     7,     7,    29,    29,    29,    30,
  1466.     30,    35,     1,     2,    11,    11,    41,    25,    12,    12,
  1467.     19,    19,    19,    19,    34,    34,    20,    20,    20,    20,
  1468.     20,    20,    20,    20,    20,    20,    20,    20,    20,    20,
  1469.     20,    44,    20,    20,    20,    28,    28,    21,    21,    42,
  1470.     42,    31,    31,    26,    26,    27,    27,    27,    27,    22,
  1471.     22,    14,    14,    14,    14,    14,    23,    23,    16,    16,
  1472.     15,    15,    15,    15,    15,    15,    18,    18,    17,    17,
  1473.     17,    17,    17,    17,    45,     4,     4,     4,     4,     4,
  1474.      4,     4,     4,     4,     4,     4,     4,     4,     4,     4,
  1475.      4,    46,     3,     3,     3,     3,     3,     3,     3,     3,
  1476.      3,     3,     3,     3,     8,     8,     8,     8,     8,     8,
  1477.      8,     8,     9,     9,    47,     9,     9,     9,     9,     9,
  1478.      9,     9,     9,     9,     9,    10,    10,    10,    24,    24,
  1479.     13,    13,    13,    13,    37,    38,    36,    39,    39,    43,
  1480.     40 };
  1481. int yyr2[]={
  1482.  
  1483.      0,     7,     3,     5,     3,     5,     1,     7,     1,     7,
  1484.      5,     5,     5,     3,     5,     5,     3,     3,     3,     2,
  1485.      2,     1,    15,     9,     3,     7,     1,     9,    11,     9,
  1486.      3,     5,     3,     5,     2,     4,     5,     5,     7,     3,
  1487.     13,    17,    17,    21,    19,     5,     5,    13,     9,     7,
  1488.      7,     1,     9,    13,     5,     3,     3,    13,    19,     3,
  1489.      4,     0,     2,     1,     5,     1,     5,     5,     5,     1,
  1490.      3,     3,     7,     3,     5,     7,     1,     3,     1,     3,
  1491.      3,     7,     3,     5,     7,     7,     1,     3,     3,     7,
  1492.      3,     5,     7,     7,     1,     9,    11,     9,     7,     7,
  1493.      7,     7,     3,     5,     7,     7,     7,     7,    11,     3,
  1494.      5,     1,     9,     7,     7,     7,     3,     5,     7,     7,
  1495.      7,    11,     3,     5,     2,     2,     7,     7,     7,     7,
  1496.      7,     7,     5,     7,     1,    11,     9,     3,     9,     5,
  1497.      5,     3,     3,     5,     5,     5,     5,     2,     1,     3,
  1498.      3,     9,     5,     5,     4,     5,     3,     0,     2,     3,
  1499.      5 };
  1500. int yychk[]={
  1501.  
  1502.  -1000,    -5,   -31,   -42,   267,    -6,    -7,   256,   269,   270,
  1503.    -11,   -12,    -1,    -4,   -37,   284,   -13,    40,   285,   -25,
  1504.     33,    -8,   123,   258,    36,    47,    -9,   -10,   291,   292,
  1505.    257,   289,   290,   261,   262,    45,    43,   267,   -31,    -7,
  1506.    256,   -32,   -34,   -42,   -43,    59,   -33,   -34,   -12,   -34,
  1507.     -2,   -37,   -40,   124,   287,   288,   266,   286,   263,    60,
  1508.     62,    63,    -4,    44,   -19,   -38,   -20,   256,   125,   -43,
  1509.    -37,   -21,   275,   276,   277,   278,   279,   -28,   282,   283,
  1510.    273,   274,    -4,   271,   280,   281,   -35,   265,   289,   290,
  1511.    -17,    -4,   256,   -24,   -13,   -25,    -8,    33,    40,   -13,
  1512.     94,    42,    47,    37,    43,    45,   -31,    91,    -9,   -13,
  1513.    -41,   -47,    40,    40,   -13,   -13,    -8,    -8,   -12,   -31,
  1514.    -12,   -19,    -4,   285,    -4,    -4,    -4,   258,    -4,    -4,
  1515.     -4,    -4,   -31,   -38,   -20,   256,   -39,   -43,   -31,   -31,
  1516.    -38,   -19,    40,   -31,    40,   -34,   -34,    40,   -16,   -15,
  1517.     -3,   256,   -13,   285,   -25,    33,    -8,   -23,    -4,   -23,
  1518.    -44,   258,   -34,    40,   -29,   258,   257,   -30,   291,   292,
  1519.    -45,   -40,   256,   -36,    41,   -36,   -26,    60,    -4,    -8,
  1520.     -8,    -8,    -8,    -8,    -8,   -17,    -4,   259,    40,   -18,
  1521.    -17,   -18,   -38,   -24,    58,   -39,   -31,   -38,    -4,   -20,
  1522.    258,   -23,   -17,   -27,    62,   264,   124,   -40,   256,   287,
  1523.    288,   266,   286,   263,    63,    -3,   265,   -24,   -25,   -34,
  1524.    -34,   -23,    91,    -4,    40,    -4,    -4,   256,    -4,   286,
  1525.     -8,    93,    47,   -18,   -36,   -36,   -39,    -4,   -31,   -36,
  1526.    275,   286,   -43,   -36,   -34,    -4,    -4,    -4,    -3,   256,
  1527.     -3,    -3,    -3,    -3,   258,    -3,    -3,   -46,   -26,   -34,
  1528.    -17,   -36,   -22,   -14,   258,   256,   258,   -36,   -31,    40,
  1529.    258,    -4,   -43,   -27,    58,    -3,    93,   -31,   -36,   -40,
  1530.    256,   -20,    -4,   -36,   -43,   -23,   -34,    -3,   -34,   -20,
  1531.    -31,   258,   256,   -36,   -31,   -23,   -36,   272,   -31,   -20,
  1532.    -36,   -31,   -31,   -31,   -20,   -20,   -20 };
  1533. int yydef[]={
  1534.  
  1535.     61,    -2,     0,    62,    59,    -2,     2,     4,     6,     8,
  1536.      0,    13,     0,    24,     0,    21,   147,     0,   148,   102,
  1537.      0,   109,    61,   150,     0,    26,   124,   125,   134,   137,
  1538.      0,     0,     0,   141,   142,     0,     0,    60,     1,     3,
  1539.      5,     0,    10,    34,    61,   159,     0,    11,    12,    14,
  1540.     15,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  1541.      0,     0,   110,    61,     0,   157,    30,    32,    61,    61,
  1542.      0,    39,     0,    61,     0,     0,     0,    -2,    76,    76,
  1543.     51,     0,     0,     0,    55,    56,     0,    94,   145,   146,
  1544.      0,    88,    90,    63,   149,   103,   132,     0,     0,   147,
  1545.      0,     0,     0,     0,     0,     0,   154,     0,   152,   153,
  1546.      0,     0,    -2,    -2,   139,   140,   143,   144,     7,    35,
  1547.      9,     0,    25,   148,    99,   100,    -2,   104,    -2,    -2,
  1548.     -2,     0,   160,   157,    31,    33,    61,   158,   155,    36,
  1549.     37,     0,     0,     0,    76,    45,    46,     0,    65,    -2,
  1550.     80,    82,   147,   148,   116,     0,   122,     0,    77,     0,
  1551.     76,     0,    54,     0,     0,    16,    17,    18,    19,    20,
  1552.      0,     0,    91,     0,   156,   133,    98,     0,     0,   126,
  1553.    127,   128,   129,   130,   131,     0,    88,     0,    -2,     0,
  1554.     -2,     0,   157,    97,     0,    61,    29,    38,     0,     0,
  1555.    150,     0,     0,     0,     0,     0,     0,     0,    83,     0,
  1556.      0,     0,     0,     0,     0,   123,   111,    63,   117,    49,
  1557.     50,     0,     0,     0,    -2,    95,    89,    93,    92,     0,
  1558.     64,   151,    27,     0,   136,   138,    23,   108,    28,    61,
  1559.      0,     0,     0,    65,    48,    66,    67,    68,    81,    85,
  1560.     84,   113,   114,    -2,   119,    -2,     0,     0,   115,    52,
  1561.      0,    61,     0,    -2,    71,    73,    96,   135,     0,     0,
  1562.      0,     0,    76,     0,     0,   112,     0,     0,    61,     0,
  1563.     74,    40,     0,    61,    76,     0,    47,   121,    53,    57,
  1564.     22,    72,    75,    61,     0,     0,    61,    61,    41,    42,
  1565.     61,     0,     0,     0,    44,    58,    43 };
  1566. typedef struct { char *t_name; int t_val; } yytoktype;
  1567. #ifndef YYDEBUG
  1568. #    define YYDEBUG    0    /* don't allow debugging */
  1569. #endif
  1570.  
  1571. #if YYDEBUG
  1572.  
  1573. yytoktype yytoks[] =
  1574. {
  1575.     "FUNC_CALL",    257,
  1576.     "NAME",    258,
  1577.     "REGEXP",    259,
  1578.     "ERROR",    260,
  1579.     "YNUMBER",    261,
  1580.     "YSTRING",    262,
  1581.     "RELOP",    263,
  1582.     "APPEND_OP",    264,
  1583.     "ASSIGNOP",    265,
  1584.     "MATCHOP",    266,
  1585.     "NEWLINE",    267,
  1586.     "CONCAT_OP",    268,
  1587.     "LEX_BEGIN",    269,
  1588.     "LEX_END",    270,
  1589.     "LEX_IF",    271,
  1590.     "LEX_ELSE",    272,
  1591.     "LEX_RETURN",    273,
  1592.     "LEX_DELETE",    274,
  1593.     "LEX_WHILE",    275,
  1594.     "LEX_DO",    276,
  1595.     "LEX_FOR",    277,
  1596.     "LEX_BREAK",    278,
  1597.     "LEX_CONTINUE",    279,
  1598.     "LEX_PRINT",    280,
  1599.     "LEX_PRINTF",    281,
  1600.     "LEX_NEXT",    282,
  1601.     "LEX_EXIT",    283,
  1602.     "LEX_FUNCTION",    284,
  1603.     "LEX_GETLINE",    285,
  1604.     "LEX_IN",    286,
  1605.     "LEX_AND",    287,
  1606.     "LEX_OR",    288,
  1607.     "INCREMENT",    289,
  1608.     "DECREMENT",    290,
  1609.     "LEX_BUILTIN",    291,
  1610.     "LEX_LENGTH",    292,
  1611.     "?",    63,
  1612.     ":",    58,
  1613.     "<",    60,
  1614.     ">",    62,
  1615.     "|",    124,
  1616.     "+",    43,
  1617.     "-",    45,
  1618.     "*",    42,
  1619.     "/",    47,
  1620.     "%",    37,
  1621.     "!",    33,
  1622.     "UNARY",    293,
  1623.     "^",    94,
  1624.     "$",    36,
  1625.     "(",    40,
  1626.     ")",    41,
  1627.     "-unknown-",    -1    /* ends search */
  1628. };
  1629.  
  1630. char * yyreds[] =
  1631. {
  1632.     "-no such reduction-",
  1633.     "start : opt_nls program opt_nls",
  1634.     "program : rule",
  1635.     "program : program rule",
  1636.     "program : error",
  1637.     "program : program error",
  1638.     "rule : LEX_BEGIN",
  1639.     "rule : LEX_BEGIN action",
  1640.     "rule : LEX_END",
  1641.     "rule : LEX_END action",
  1642.     "rule : LEX_BEGIN statement_term",
  1643.     "rule : LEX_END statement_term",
  1644.     "rule : pattern action",
  1645.     "rule : action",
  1646.     "rule : pattern statement_term",
  1647.     "rule : function_prologue function_body",
  1648.     "func_name : NAME",
  1649.     "func_name : FUNC_CALL",
  1650.     "func_name : lex_builtin",
  1651.     "lex_builtin : LEX_BUILTIN",
  1652.     "lex_builtin : LEX_LENGTH",
  1653.     "function_prologue : LEX_FUNCTION",
  1654.     "function_prologue : LEX_FUNCTION func_name '(' opt_param_list r_paren opt_nls",
  1655.     "function_body : l_brace statements r_brace opt_semi",
  1656.     "pattern : exp",
  1657.     "pattern : exp comma exp",
  1658.     "regexp : '/'",
  1659.     "regexp : '/' REGEXP '/'",
  1660.     "action : l_brace statements r_brace opt_semi opt_nls",
  1661.     "action : l_brace r_brace opt_semi opt_nls",
  1662.     "statements : statement",
  1663.     "statements : statements statement",
  1664.     "statements : error",
  1665.     "statements : statements error",
  1666.     "statement_term : nls",
  1667.     "statement_term : semi opt_nls",
  1668.     "statement : semi opt_nls",
  1669.     "statement : l_brace r_brace",
  1670.     "statement : l_brace statements r_brace",
  1671.     "statement : if_statement",
  1672.     "statement : LEX_WHILE '(' exp r_paren opt_nls statement",
  1673.     "statement : LEX_DO opt_nls statement LEX_WHILE '(' exp r_paren opt_nls",
  1674.     "statement : LEX_FOR '(' NAME LEX_IN NAME r_paren opt_nls statement",
  1675.     "statement : LEX_FOR '(' opt_exp semi exp semi opt_exp r_paren opt_nls statement",
  1676.     "statement : LEX_FOR '(' opt_exp semi semi opt_exp r_paren opt_nls statement",
  1677.     "statement : LEX_BREAK statement_term",
  1678.     "statement : LEX_CONTINUE statement_term",
  1679.     "statement : print '(' expression_list r_paren output_redir statement_term",
  1680.     "statement : print opt_rexpression_list output_redir statement_term",
  1681.     "statement : LEX_NEXT opt_exp statement_term",
  1682.     "statement : LEX_EXIT opt_exp statement_term",
  1683.     "statement : LEX_RETURN",
  1684.     "statement : LEX_RETURN opt_exp statement_term",
  1685.     "statement : LEX_DELETE NAME '[' expression_list ']' statement_term",
  1686.     "statement : exp statement_term",
  1687.     "print : LEX_PRINT",
  1688.     "print : LEX_PRINTF",
  1689.     "if_statement : LEX_IF '(' exp r_paren opt_nls statement",
  1690.     "if_statement : LEX_IF '(' exp r_paren opt_nls statement LEX_ELSE opt_nls statement",
  1691.     "nls : NEWLINE",
  1692.     "nls : nls NEWLINE",
  1693.     "opt_nls : /* empty */",
  1694.     "opt_nls : nls",
  1695.     "input_redir : /* empty */",
  1696.     "input_redir : '<' simp_exp",
  1697.     "output_redir : /* empty */",
  1698.     "output_redir : '>' exp",
  1699.     "output_redir : APPEND_OP exp",
  1700.     "output_redir : '|' exp",
  1701.     "opt_param_list : /* empty */",
  1702.     "opt_param_list : param_list",
  1703.     "param_list : NAME",
  1704.     "param_list : param_list comma NAME",
  1705.     "param_list : error",
  1706.     "param_list : param_list error",
  1707.     "param_list : param_list comma error",
  1708.     "opt_exp : /* empty */",
  1709.     "opt_exp : exp",
  1710.     "opt_rexpression_list : /* empty */",
  1711.     "opt_rexpression_list : rexpression_list",
  1712.     "rexpression_list : rexp",
  1713.     "rexpression_list : rexpression_list comma rexp",
  1714.     "rexpression_list : error",
  1715.     "rexpression_list : rexpression_list error",
  1716.     "rexpression_list : rexpression_list error rexp",
  1717.     "rexpression_list : rexpression_list comma error",
  1718.     "opt_expression_list : /* empty */",
  1719.     "opt_expression_list : expression_list",
  1720.     "expression_list : exp",
  1721.     "expression_list : expression_list comma exp",
  1722.     "expression_list : error",
  1723.     "expression_list : expression_list error",
  1724.     "expression_list : expression_list error exp",
  1725.     "expression_list : expression_list comma error",
  1726.     "exp : variable ASSIGNOP",
  1727.     "exp : variable ASSIGNOP exp",
  1728.     "exp : '(' expression_list r_paren LEX_IN NAME",
  1729.     "exp : exp '|' LEX_GETLINE opt_variable",
  1730.     "exp : LEX_GETLINE opt_variable input_redir",
  1731.     "exp : exp LEX_AND exp",
  1732.     "exp : exp LEX_OR exp",
  1733.     "exp : exp MATCHOP exp",
  1734.     "exp : regexp",
  1735.     "exp : '!' regexp",
  1736.     "exp : exp LEX_IN NAME",
  1737.     "exp : exp RELOP exp",
  1738.     "exp : exp '<' exp",
  1739.     "exp : exp '>' exp",
  1740.     "exp : exp '?' exp ':' exp",
  1741.     "exp : simp_exp",
  1742.     "exp : exp exp",
  1743.     "rexp : variable ASSIGNOP",
  1744.     "rexp : variable ASSIGNOP rexp",
  1745.     "rexp : rexp LEX_AND rexp",
  1746.     "rexp : rexp LEX_OR rexp",
  1747.     "rexp : LEX_GETLINE opt_variable input_redir",
  1748.     "rexp : regexp",
  1749.     "rexp : '!' regexp",
  1750.     "rexp : rexp MATCHOP rexp",
  1751.     "rexp : rexp LEX_IN NAME",
  1752.     "rexp : rexp RELOP rexp",
  1753.     "rexp : rexp '?' rexp ':' rexp",
  1754.     "rexp : simp_exp",
  1755.     "rexp : rexp rexp",
  1756.     "simp_exp : non_post_simp_exp",
  1757.     "simp_exp : post_inc_dec_exp",
  1758.     "simp_exp : simp_exp '^' simp_exp",
  1759.     "simp_exp : simp_exp '*' simp_exp",
  1760.     "simp_exp : simp_exp '/' simp_exp",
  1761.     "simp_exp : simp_exp '%' simp_exp",
  1762.     "simp_exp : simp_exp '+' simp_exp",
  1763.     "simp_exp : simp_exp '-' simp_exp",
  1764.     "non_post_simp_exp : '!' simp_exp",
  1765.     "non_post_simp_exp : '(' exp r_paren",
  1766.     "non_post_simp_exp : LEX_BUILTIN",
  1767.     "non_post_simp_exp : LEX_BUILTIN '(' opt_expression_list r_paren",
  1768.     "non_post_simp_exp : LEX_LENGTH '(' opt_expression_list r_paren",
  1769.     "non_post_simp_exp : LEX_LENGTH",
  1770.     "non_post_simp_exp : FUNC_CALL '(' opt_expression_list r_paren",
  1771.     "non_post_simp_exp : INCREMENT variable",
  1772.     "non_post_simp_exp : DECREMENT variable",
  1773.     "non_post_simp_exp : YNUMBER",
  1774.     "non_post_simp_exp : YSTRING",
  1775.     "non_post_simp_exp : '-' simp_exp",
  1776.     "non_post_simp_exp : '+' simp_exp",
  1777.     "post_inc_dec_exp : variable INCREMENT",
  1778.     "post_inc_dec_exp : variable DECREMENT",
  1779.     "post_inc_dec_exp : variable",
  1780.     "opt_variable : /* empty */",
  1781.     "opt_variable : variable",
  1782.     "variable : NAME",
  1783.     "variable : NAME '[' expression_list ']'",
  1784.     "variable : '$' non_post_simp_exp",
  1785.     "variable : '$' variable",
  1786.     "l_brace : '{' opt_nls",
  1787.     "r_brace : '}' opt_nls",
  1788.     "r_paren : ')'",
  1789.     "opt_semi : /* empty */",
  1790.     "opt_semi : semi",
  1791.     "semi : ';'",
  1792.     "comma : ',' opt_nls",
  1793. };
  1794. #endif /* YYDEBUG */
  1795. #line 1 "/usr/lib/yaccpar"
  1796. /*    @(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10    */
  1797.  
  1798. /*
  1799. ** Skeleton parser driver for yacc output
  1800. */
  1801.  
  1802. /*
  1803. ** yacc user known macros and defines
  1804. */
  1805. #define YYERROR        goto yyerrlab
  1806. #define YYACCEPT    { free(yys); free(yyv); return(0); }
  1807. #define YYABORT        { free(yys); free(yyv); return(1); }
  1808. #define YYBACKUP( newtoken, newvalue )\
  1809. {\
  1810.     if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
  1811.     {\
  1812.         yyerror( "syntax error - cannot backup" );\
  1813.         goto yyerrlab;\
  1814.     }\
  1815.     yychar = newtoken;\
  1816.     yystate = *yyps;\
  1817.     yylval = newvalue;\
  1818.     goto yynewstate;\
  1819. }
  1820. #define YYRECOVERING()    (!!yyerrflag)
  1821. #ifndef YYDEBUG
  1822. #    define YYDEBUG    1    /* make debugging available */
  1823. #endif
  1824.  
  1825. /*
  1826. ** user known globals
  1827. */
  1828. int yydebug;            /* set to 1 to get debugging */
  1829.  
  1830. /*
  1831. ** driver internal defines
  1832. */
  1833. #define YYFLAG        (-1000)
  1834.  
  1835. /*
  1836. ** static variables used by the parser
  1837. */
  1838. static YYSTYPE *yyv;            /* value stack */
  1839. static int *yys;            /* state stack */
  1840.  
  1841. static YYSTYPE *yypv;            /* top of value stack */
  1842. static int *yyps;            /* top of state stack */
  1843.  
  1844. static int yystate;            /* current state */
  1845. static int yytmp;            /* extra var (lasts between blocks) */
  1846.  
  1847. int yynerrs;            /* number of errors */
  1848.  
  1849. int yyerrflag;            /* error recovery flag */
  1850. int yychar;            /* current input token number */
  1851.  
  1852.  
  1853. /*
  1854. ** yyparse - return 0 if worked, 1 if syntax error not recovered from
  1855. */
  1856. int
  1857. yyparse()
  1858. {
  1859.     register YYSTYPE *yypvt;    /* top of value stack for $vars */
  1860.     unsigned yymaxdepth = YYMAXDEPTH;
  1861.  
  1862.     /*
  1863.     ** Initialize externals - yyparse may be called more than once
  1864.     */
  1865.     yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));
  1866.     yys = (int*)malloc(yymaxdepth*sizeof(int));
  1867.     if (!yyv || !yys)
  1868.     {
  1869.         yyerror( "out of memory" );
  1870.         return(1);
  1871.     }
  1872.     yypv = &yyv[-1];
  1873.     yyps = &yys[-1];
  1874.     yystate = 0;
  1875.     yytmp = 0;
  1876.     yynerrs = 0;
  1877.     yyerrflag = 0;
  1878.     yychar = -1;
  1879.  
  1880.     goto yystack;
  1881.     {
  1882.         register YYSTYPE *yy_pv;    /* top of value stack */
  1883.         register int *yy_ps;        /* top of state stack */
  1884.         register int yy_state;        /* current state */
  1885.         register int  yy_n;        /* internal state number info */
  1886.  
  1887.         /*
  1888.         ** get globals into registers.
  1889.         ** branch to here only if YYBACKUP was called.
  1890.         */
  1891.     yynewstate:
  1892.         yy_pv = yypv;
  1893.         yy_ps = yyps;
  1894.         yy_state = yystate;
  1895.         goto yy_newstate;
  1896.  
  1897.         /*
  1898.         ** get globals into registers.
  1899.         ** either we just started, or we just finished a reduction
  1900.         */
  1901.     yystack:
  1902.         yy_pv = yypv;
  1903.         yy_ps = yyps;
  1904.         yy_state = yystate;
  1905.  
  1906.         /*
  1907.         ** top of for (;;) loop while no reductions done
  1908.         */
  1909.     yy_stack:
  1910.         /*
  1911.         ** put a state and value onto the stacks
  1912.         */
  1913. #if YYDEBUG
  1914.         /*
  1915.         ** if debugging, look up token value in list of value vs.
  1916.         ** name pairs.  0 and negative (-1) are special values.
  1917.         ** Note: linear search is used since time is not a real
  1918.         ** consideration while debugging.
  1919.         */
  1920.         if ( yydebug )
  1921.         {
  1922.             register int yy_i;
  1923.  
  1924.             (void)printf( "State %d, token ", yy_state );
  1925.             if ( yychar == 0 )
  1926.                 (void)printf( "end-of-file\n" );
  1927.             else if ( yychar < 0 )
  1928.                 (void)printf( "-none-\n" );
  1929.             else
  1930.             {
  1931.                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
  1932.                     yy_i++ )
  1933.                 {
  1934.                     if ( yytoks[yy_i].t_val == yychar )
  1935.                         break;
  1936.                 }
  1937.                 (void)printf( "%s\n", yytoks[yy_i].t_name );
  1938.             }
  1939.         }
  1940. #endif /* YYDEBUG */
  1941.         if ( ++yy_ps >= &yys[ yymaxdepth ] )    /* room on stack? */
  1942.         {
  1943.             /*
  1944.             ** reallocate and recover.  Note that pointers
  1945.             ** have to be reset, or bad things will happen
  1946.             */
  1947.             int yyps_index = (yy_ps - yys);
  1948.             int yypv_index = (yy_pv - yyv);
  1949.             int yypvt_index = (yypvt - yyv);
  1950.             yymaxdepth += YYMAXDEPTH;
  1951.             yyv = (YYSTYPE*)realloc((char*)yyv,
  1952.                 yymaxdepth * sizeof(YYSTYPE));
  1953.             yys = (int*)realloc((char*)yys,
  1954.                 yymaxdepth * sizeof(int));
  1955.             if (!yyv || !yys)
  1956.             {
  1957.                 yyerror( "yacc stack overflow" );
  1958.                 return(1);
  1959.             }
  1960.             yy_ps = yys + yyps_index;
  1961.             yy_pv = yyv + yypv_index;
  1962.             yypvt = yyv + yypvt_index;
  1963.         }
  1964.         *yy_ps = yy_state;
  1965.         *++yy_pv = yyval;
  1966.  
  1967.         /*
  1968.         ** we have a new state - find out what to do
  1969.         */
  1970.     yy_newstate:
  1971.         if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
  1972.             goto yydefault;        /* simple state */
  1973. #if YYDEBUG
  1974.         /*
  1975.         ** if debugging, need to mark whether new token grabbed
  1976.         */
  1977.         yytmp = yychar < 0;
  1978. #endif
  1979.         if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
  1980.             yychar = 0;        /* reached EOF */
  1981. #if YYDEBUG
  1982.         if ( yydebug && yytmp )
  1983.         {
  1984.             register int yy_i;
  1985.  
  1986.             (void)printf( "Received token " );
  1987.             if ( yychar == 0 )
  1988.                 (void)printf( "end-of-file\n" );
  1989.             else if ( yychar < 0 )
  1990.                 (void)printf( "-none-\n" );
  1991.             else
  1992.             {
  1993.                 for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
  1994.                     yy_i++ )
  1995.                 {
  1996.                     if ( yytoks[yy_i].t_val == yychar )
  1997.                         break;
  1998.                 }
  1999.                 (void)printf( "%s\n", yytoks[yy_i].t_name );
  2000.             }
  2001.         }
  2002. #endif /* YYDEBUG */
  2003.         if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
  2004.             goto yydefault;
  2005.         if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar )    /*valid shift*/
  2006.         {
  2007.             yychar = -1;
  2008.             yyval = yylval;
  2009.             yy_state = yy_n;
  2010.             if ( yyerrflag > 0 )
  2011.                 yyerrflag--;
  2012.             goto yy_stack;
  2013.         }
  2014.  
  2015.     yydefault:
  2016.         if ( ( yy_n = yydef[ yy_state ] ) == -2 )
  2017.         {
  2018. #if YYDEBUG
  2019.             yytmp = yychar < 0;
  2020. #endif
  2021.             if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
  2022.                 yychar = 0;        /* reached EOF */
  2023. #if YYDEBUG
  2024.             if ( yydebug && yytmp )
  2025.             {
  2026.                 register int yy_i;
  2027.  
  2028.                 (void)printf( "Received token " );
  2029.                 if ( yychar == 0 )
  2030.                     (void)printf( "end-of-file\n" );
  2031.                 else if ( yychar < 0 )
  2032.                     (void)printf( "-none-\n" );
  2033.                 else
  2034.                 {
  2035.                     for ( yy_i = 0;
  2036.                         yytoks[yy_i].t_val >= 0;
  2037.                         yy_i++ )
  2038.                     {
  2039.                         if ( yytoks[yy_i].t_val
  2040.                             == yychar )
  2041.                         {
  2042.                             break;
  2043.                         }
  2044.                     }
  2045.                     (void)printf( "%s\n", yytoks[yy_i].t_name );
  2046.                 }
  2047.             }
  2048. #endif /* YYDEBUG */
  2049.             /*
  2050.             ** look through exception table
  2051.             */
  2052.             {
  2053.                 register int *yyxi = yyexca;
  2054.  
  2055.                 while ( ( *yyxi != -1 ) ||
  2056.                     ( yyxi[1] != yy_state ) )
  2057.                 {
  2058.                     yyxi += 2;
  2059.                 }
  2060.                 while ( ( *(yyxi += 2) >= 0 ) &&
  2061.                     ( *yyxi != yychar ) )
  2062.                     ;
  2063.                 if ( ( yy_n = yyxi[1] ) < 0 )
  2064.                     YYACCEPT;
  2065.             }
  2066.         }
  2067.  
  2068.         /*
  2069.         ** check for syntax error
  2070.         */
  2071.         if ( yy_n == 0 )    /* have an error */
  2072.         {
  2073.             /* no worry about speed here! */
  2074.             switch ( yyerrflag )
  2075.             {
  2076.             case 0:        /* new error */
  2077.                 yyerror( "syntax error" );
  2078.                 goto skip_init;
  2079.             yyerrlab:
  2080.                 /*
  2081.                 ** get globals into registers.
  2082.                 ** we have a user generated syntax type error
  2083.                 */
  2084.                 yy_pv = yypv;
  2085.                 yy_ps = yyps;
  2086.                 yy_state = yystate;
  2087.                 yynerrs++;
  2088.             skip_init:
  2089.             case 1:
  2090.             case 2:        /* incompletely recovered error */
  2091.                     /* try again... */
  2092.                 yyerrflag = 3;
  2093.                 /*
  2094.                 ** find state where "error" is a legal
  2095.                 ** shift action
  2096.                 */
  2097.                 while ( yy_ps >= yys )
  2098.                 {
  2099.                     yy_n = yypact[ *yy_ps ] + YYERRCODE;
  2100.                     if ( yy_n >= 0 && yy_n < YYLAST &&
  2101.                         yychk[yyact[yy_n]] == YYERRCODE)                    {
  2102.                         /*
  2103.                         ** simulate shift of "error"
  2104.                         */
  2105.                         yy_state = yyact[ yy_n ];
  2106.                         goto yy_stack;
  2107.                     }
  2108.                     /*
  2109.                     ** current state has no shift on
  2110.                     ** "error", pop stack
  2111.                     */
  2112. #if YYDEBUG
  2113. #    define _POP_ "Error recovery pops state %d, uncovers state %d\n"
  2114.                     if ( yydebug )
  2115.                         (void)printf( _POP_, *yy_ps,
  2116.                             yy_ps[-1] );
  2117. #    undef _POP_
  2118. #endif
  2119.                     yy_ps--;
  2120.                     yy_pv--;
  2121.                 }
  2122.                 /*
  2123.                 ** there is no state on stack with "error" as
  2124.                 ** a valid shift.  give up.
  2125.                 */
  2126.                 YYABORT;
  2127.             case 3:        /* no shift yet; eat a token */
  2128. #if YYDEBUG
  2129.                 /*
  2130.                 ** if debugging, look up token in list of
  2131.                 ** pairs.  0 and negative shouldn't occur,
  2132.                 ** but since timing doesn't matter when
  2133.                 ** debugging, it doesn't hurt to leave the
  2134.                 ** tests here.
  2135.                 */
  2136.                 if ( yydebug )
  2137.                 {
  2138.                     register int yy_i;
  2139.  
  2140.                     (void)printf( "Error recovery discards " );
  2141.                     if ( yychar == 0 )
  2142.                         (void)printf( "token end-of-file\n" );
  2143.                     else if ( yychar < 0 )
  2144.                         (void)printf( "token -none-\n" );
  2145.                     else
  2146.                     {
  2147.                         for ( yy_i = 0;
  2148.                             yytoks[yy_i].t_val >= 0;
  2149.                             yy_i++ )
  2150.                         {
  2151.                             if ( yytoks[yy_i].t_val
  2152.                                 == yychar )
  2153.                             {
  2154.                                 break;
  2155.                             }
  2156.                         }
  2157.                         (void)printf( "token %s\n",
  2158.                             yytoks[yy_i].t_name );
  2159.                     }
  2160.                 }
  2161. #endif /* YYDEBUG */
  2162.                 if ( yychar == 0 )    /* reached EOF. quit */
  2163.                     YYABORT;
  2164.                 yychar = -1;
  2165.                 goto yy_newstate;
  2166.             }
  2167.         }/* end if ( yy_n == 0 ) */
  2168.         /*
  2169.         ** reduction by production yy_n
  2170.         ** put stack tops, etc. so things right after switch
  2171.         */
  2172. #if YYDEBUG
  2173.         /*
  2174.         ** if debugging, print the string that is the user's
  2175.         ** specification of the reduction which is just about
  2176.         ** to be done.
  2177.         */
  2178.         if ( yydebug )
  2179.             (void)printf( "Reduce by (%d) \"%s\"\n",
  2180.                 yy_n, yyreds[ yy_n ] );
  2181. #endif
  2182.         yytmp = yy_n;            /* value to switch over */
  2183.         yypvt = yy_pv;            /* $vars top of value stack */
  2184.         /*
  2185.         ** Look in goto table for next state
  2186.         ** Sorry about using yy_state here as temporary
  2187.         ** register variable, but why not, if it works...
  2188.         ** If yyr2[ yy_n ] doesn't have the low order bit
  2189.         ** set, then there is no action to be done for
  2190.         ** this reduction.  So, no saving & unsaving of
  2191.         ** registers done.  The only difference between the
  2192.         ** code just after the if and the body of the if is
  2193.         ** the goto yy_stack in the body.  This way the test
  2194.         ** can be made before the choice of what to do is needed.
  2195.         */
  2196.         {
  2197.             /* length of production doubled with extra bit */
  2198.             register int yy_len = yyr2[ yy_n ];
  2199.  
  2200.             if ( !( yy_len & 01 ) )
  2201.             {
  2202.                 yy_len >>= 1;
  2203.                 yyval = ( yy_pv -= yy_len )[1];    /* $$ = $1 */
  2204.                 yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
  2205.                     *( yy_ps -= yy_len ) + 1;
  2206.                 if ( yy_state >= YYLAST ||
  2207.                     yychk[ yy_state =
  2208.                     yyact[ yy_state ] ] != -yy_n )
  2209.                 {
  2210.                     yy_state = yyact[ yypgo[ yy_n ] ];
  2211.                 }
  2212.                 goto yy_stack;
  2213.             }
  2214.             yy_len >>= 1;
  2215.             yyval = ( yy_pv -= yy_len )[1];    /* $$ = $1 */
  2216.             yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
  2217.                 *( yy_ps -= yy_len ) + 1;
  2218.             if ( yy_state >= YYLAST ||
  2219.                 yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
  2220.             {
  2221.                 yy_state = yyact[ yypgo[ yy_n ] ];
  2222.             }
  2223.         }
  2224.                     /* save until reenter driver code */
  2225.         yystate = yy_state;
  2226.         yyps = yy_ps;
  2227.         yypv = yy_pv;
  2228.     }
  2229.     /*
  2230.     ** code supplied by user is placed in this switch
  2231.     */
  2232.     switch( yytmp )
  2233.     {
  2234.         
  2235. case 1:
  2236. # line 137 "awk.y"
  2237. { expression_value = yypvt[-1].nodeval; } break;
  2238. case 2:
  2239. # line 142 "awk.y"
  2240. { 
  2241.             if (yypvt[-0].nodeval != NULL)
  2242.                 yyval.nodeval = yypvt[-0].nodeval;
  2243.             else
  2244.                 yyval.nodeval = NULL;
  2245.             yyerrok;
  2246.         } break;
  2247. case 3:
  2248. # line 151 "awk.y"
  2249. {
  2250.             if (yypvt[-0].nodeval == NULL)
  2251.                 yyval.nodeval = yypvt[-1].nodeval;
  2252.             else if (yypvt[-1].nodeval == NULL)
  2253.                 yyval.nodeval = yypvt[-0].nodeval;
  2254.             else {
  2255.                 if (yypvt[-1].nodeval->type != Node_rule_list)
  2256.                     yypvt[-1].nodeval = node(yypvt[-1].nodeval, Node_rule_list,
  2257.                         (NODE*)NULL);
  2258.                 yyval.nodeval = append_right (yypvt[-1].nodeval,
  2259.                    node(yypvt[-0].nodeval, Node_rule_list,(NODE *) NULL));
  2260.             }
  2261.             yyerrok;
  2262.         } break;
  2263. case 4:
  2264. # line 165 "awk.y"
  2265. { yyval.nodeval = NULL; } break;
  2266. case 5:
  2267. # line 166 "awk.y"
  2268. { yyval.nodeval = NULL; } break;
  2269. case 6:
  2270. # line 170 "awk.y"
  2271. { io_allowed = 0; } break;
  2272. case 7:
  2273. # line 172 "awk.y"
  2274. {
  2275.         if (begin_block) {
  2276.             if (begin_block->type != Node_rule_list)
  2277.                 begin_block = node(begin_block, Node_rule_list,
  2278.                     (NODE *)NULL);
  2279.             (void) append_right (begin_block, node(
  2280.                 node((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval),
  2281.                 Node_rule_list, (NODE *)NULL) );
  2282.         } else
  2283.             begin_block = node((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval);
  2284.         yyval.nodeval = NULL;
  2285.         io_allowed = 1;
  2286.         yyerrok;
  2287.       } break;
  2288. case 8:
  2289. # line 186 "awk.y"
  2290. { io_allowed = 0; } break;
  2291. case 9:
  2292. # line 188 "awk.y"
  2293. {
  2294.         if (end_block) {
  2295.             if (end_block->type != Node_rule_list)
  2296.                 end_block = node(end_block, Node_rule_list,
  2297.                     (NODE *)NULL);
  2298.             (void) append_right (end_block, node(
  2299.                 node((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval),
  2300.                 Node_rule_list, (NODE *)NULL));
  2301.         } else
  2302.             end_block = node((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval);
  2303.         yyval.nodeval = NULL;
  2304.         io_allowed = 1;
  2305.         yyerrok;
  2306.       } break;
  2307. case 10:
  2308. # line 203 "awk.y"
  2309. {
  2310.         warning("BEGIN blocks must have an action part");
  2311.         errcount++;
  2312.         yyerrok;
  2313.       } break;
  2314. case 11:
  2315. # line 209 "awk.y"
  2316. {
  2317.         warning("END blocks must have an action part");
  2318.         errcount++;
  2319.         yyerrok;
  2320.       } break;
  2321. case 12:
  2322. # line 215 "awk.y"
  2323. { yyval.nodeval = node (yypvt[-1].nodeval, Node_rule_node, yypvt[-0].nodeval); yyerrok; } break;
  2324. case 13:
  2325. # line 217 "awk.y"
  2326. { yyval.nodeval = node ((NODE *)NULL, Node_rule_node, yypvt[-0].nodeval); yyerrok; } break;
  2327. case 14:
  2328. # line 219 "awk.y"
  2329. {
  2330.           yyval.nodeval = node (yypvt[-1].nodeval,
  2331.                  Node_rule_node,
  2332.                  node(node(node(make_number(0.0),
  2333.                         Node_field_spec,
  2334.                         (NODE *) NULL),
  2335.                     Node_expression_list,
  2336.                     (NODE *) NULL),
  2337.                   Node_K_print,
  2338.                   (NODE *) NULL));
  2339.           yyerrok;
  2340.         } break;
  2341. case 15:
  2342. # line 232 "awk.y"
  2343. {
  2344.             func_install(yypvt[-1].nodeval, yypvt[-0].nodeval);
  2345.             yyval.nodeval = NULL;
  2346.             yyerrok;
  2347.         } break;
  2348. case 16:
  2349. # line 241 "awk.y"
  2350. { yyval.sval = yypvt[-0].sval; } break;
  2351. case 17:
  2352. # line 243 "awk.y"
  2353. { yyval.sval = yypvt[-0].sval; } break;
  2354. case 18:
  2355. # line 245 "awk.y"
  2356. {
  2357.         yyerror("%s() is a built-in function, it cannot be redefined",
  2358.             tokstart);
  2359.         errcount++;
  2360.         /* yyerrok; */
  2361.       } break;
  2362. case 21:
  2363. # line 260 "awk.y"
  2364. {
  2365.             param_counter = 0;
  2366.         } break;
  2367. case 22:
  2368. # line 264 "awk.y"
  2369. {
  2370.             yyval.nodeval = append_right(make_param(yypvt[-4].sval), yypvt[-2].nodeval);
  2371.             can_return = 1;
  2372.         } break;
  2373. case 23:
  2374. # line 272 "awk.y"
  2375. {
  2376.         yyval.nodeval = yypvt[-2].nodeval;
  2377.         can_return = 0;
  2378.       } break;
  2379. case 24:
  2380. # line 281 "awk.y"
  2381. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2382. case 25:
  2383. # line 283 "awk.y"
  2384. { yyval.nodeval = mkrangenode ( node(yypvt[-2].nodeval, Node_cond_pair, yypvt[-0].nodeval) ); } break;
  2385. case 26:
  2386. # line 292 "awk.y"
  2387. { ++want_regexp; } break;
  2388. case 27:
  2389. # line 294 "awk.y"
  2390. {
  2391.           NODE *n;
  2392.  
  2393.           getnode(n);
  2394.           n->type = Node_regex;
  2395.           n->re_exp = make_string(yypvt[-1].sval, strlen(yypvt[-1].sval));
  2396.           n->re_reg = mk_re_parse(yypvt[-1].sval, 0);
  2397.           n->re_text = NULL;
  2398.           n->re_flags = CONST;
  2399.           n->re_cnt = 1;
  2400.           yyval.nodeval = n;
  2401.         } break;
  2402. case 28:
  2403. # line 310 "awk.y"
  2404. { yyval.nodeval = yypvt[-3].nodeval ; } break;
  2405. case 29:
  2406. # line 312 "awk.y"
  2407. { yyval.nodeval = NULL; } break;
  2408. case 30:
  2409. # line 317 "awk.y"
  2410. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2411. case 31:
  2412. # line 319 "awk.y"
  2413. {
  2414.             if (yypvt[-1].nodeval == NULL || yypvt[-1].nodeval->type != Node_statement_list)
  2415.                 yypvt[-1].nodeval = node(yypvt[-1].nodeval, Node_statement_list,(NODE *)NULL);
  2416.                 yyval.nodeval = append_right(yypvt[-1].nodeval,
  2417.                 node( yypvt[-0].nodeval, Node_statement_list, (NODE *)NULL));
  2418.                 yyerrok;
  2419.         } break;
  2420. case 32:
  2421. # line 327 "awk.y"
  2422. { yyval.nodeval = NULL; } break;
  2423. case 33:
  2424. # line 329 "awk.y"
  2425. { yyval.nodeval = NULL; } break;
  2426. case 36:
  2427. # line 339 "awk.y"
  2428. { yyval.nodeval = NULL; } break;
  2429. case 37:
  2430. # line 341 "awk.y"
  2431. { yyval.nodeval = NULL; } break;
  2432. case 38:
  2433. # line 343 "awk.y"
  2434. { yyval.nodeval = yypvt[-1].nodeval; } break;
  2435. case 39:
  2436. # line 345 "awk.y"
  2437. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2438. case 40:
  2439. # line 347 "awk.y"
  2440. { yyval.nodeval = node (yypvt[-3].nodeval, Node_K_while, yypvt[-0].nodeval); } break;
  2441. case 41:
  2442. # line 349 "awk.y"
  2443. { yyval.nodeval = node (yypvt[-2].nodeval, Node_K_do, yypvt[-5].nodeval); } break;
  2444. case 42:
  2445. # line 351 "awk.y"
  2446. {
  2447.         yyval.nodeval = node (yypvt[-0].nodeval, Node_K_arrayfor, make_for_loop(variable(yypvt[-5].sval,1),
  2448.             (NODE *)NULL, variable(yypvt[-3].sval,1)));
  2449.       } break;
  2450. case 43:
  2451. # line 356 "awk.y"
  2452. {
  2453.         yyval.nodeval = node(yypvt[-0].nodeval, Node_K_for, (NODE *)make_for_loop(yypvt[-7].nodeval, yypvt[-5].nodeval, yypvt[-3].nodeval));
  2454.       } break;
  2455. case 44:
  2456. # line 360 "awk.y"
  2457. {
  2458.         yyval.nodeval = node (yypvt[-0].nodeval, Node_K_for,
  2459.             (NODE *)make_for_loop(yypvt[-6].nodeval, (NODE *)NULL, yypvt[-3].nodeval));
  2460.       } break;
  2461. case 45:
  2462. # line 366 "awk.y"
  2463. { yyval.nodeval = node ((NODE *)NULL, Node_K_break, (NODE *)NULL); } break;
  2464. case 46:
  2465. # line 369 "awk.y"
  2466. { yyval.nodeval = node ((NODE *)NULL, Node_K_continue, (NODE *)NULL); } break;
  2467. case 47:
  2468. # line 371 "awk.y"
  2469. { yyval.nodeval = node (yypvt[-3].nodeval, yypvt[-5].nodetypeval, yypvt[-1].nodeval); } break;
  2470. case 48:
  2471. # line 373 "awk.y"
  2472. {
  2473.             if (yypvt[-3].nodetypeval == Node_K_print && yypvt[-2].nodeval == NULL)
  2474.                 yypvt[-2].nodeval = node(node(make_number(0.0),
  2475.                            Node_field_spec,
  2476.                            (NODE *) NULL),
  2477.                       Node_expression_list,
  2478.                       (NODE *) NULL);
  2479.  
  2480.             yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-3].nodetypeval, yypvt[-1].nodeval);
  2481.         } break;
  2482. case 49:
  2483. # line 384 "awk.y"
  2484. { NODETYPE type;
  2485.  
  2486.           if (! io_allowed) yyerror("next used in BEGIN or END action");
  2487.           if (yypvt[-1].nodeval && yypvt[-1].nodeval == lookup("file")) {
  2488.             if (do_lint)
  2489.                 warning("`next file' is a gawk extension");
  2490.             else if (strict || do_posix)
  2491.                 yyerror("`next file' is a gawk extension");
  2492.             type = Node_K_nextfile;
  2493.           } else type = Node_K_next;
  2494.           yyval.nodeval = node ((NODE *)NULL, type, (NODE *)NULL);
  2495.         } break;
  2496. case 50:
  2497. # line 397 "awk.y"
  2498. { yyval.nodeval = node (yypvt[-1].nodeval, Node_K_exit, (NODE *)NULL); } break;
  2499. case 51:
  2500. # line 399 "awk.y"
  2501. { if (! can_return) yyerror("return used outside function context"); } break;
  2502. case 52:
  2503. # line 401 "awk.y"
  2504. { yyval.nodeval = node (yypvt[-1].nodeval, Node_K_return, (NODE *)NULL); } break;
  2505. case 53:
  2506. # line 403 "awk.y"
  2507. { yyval.nodeval = node (variable(yypvt[-4].sval,1), Node_K_delete, yypvt[-2].nodeval); } break;
  2508. case 54:
  2509. # line 405 "awk.y"
  2510. { yyval.nodeval = yypvt[-1].nodeval; } break;
  2511. case 55:
  2512. # line 410 "awk.y"
  2513. { yyval.nodetypeval = yypvt[-0].nodetypeval; } break;
  2514. case 56:
  2515. # line 412 "awk.y"
  2516. { yyval.nodetypeval = yypvt[-0].nodetypeval; } break;
  2517. case 57:
  2518. # line 417 "awk.y"
  2519. {
  2520.         yyval.nodeval = node(yypvt[-3].nodeval, Node_K_if, 
  2521.             node(yypvt[-0].nodeval, Node_if_branches, (NODE *)NULL));
  2522.       } break;
  2523. case 58:
  2524. # line 423 "awk.y"
  2525. { yyval.nodeval = node (yypvt[-6].nodeval, Node_K_if,
  2526.                 node (yypvt[-3].nodeval, Node_if_branches, yypvt[-0].nodeval)); } break;
  2527. case 59:
  2528. # line 429 "awk.y"
  2529. { want_assign = 0; } break;
  2530. case 63:
  2531. # line 440 "awk.y"
  2532. { yyval.nodeval = NULL; } break;
  2533. case 64:
  2534. # line 442 "awk.y"
  2535. { yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_input, (NODE *)NULL); } break;
  2536. case 65:
  2537. # line 447 "awk.y"
  2538. { yyval.nodeval = NULL; } break;
  2539. case 66:
  2540. # line 449 "awk.y"
  2541. { yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_output, (NODE *)NULL); } break;
  2542. case 67:
  2543. # line 451 "awk.y"
  2544. { yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_append, (NODE *)NULL); } break;
  2545. case 68:
  2546. # line 453 "awk.y"
  2547. { yyval.nodeval = node (yypvt[-0].nodeval, Node_redirect_pipe, (NODE *)NULL); } break;
  2548. case 69:
  2549. # line 458 "awk.y"
  2550. { yyval.nodeval = NULL; } break;
  2551. case 70:
  2552. # line 460 "awk.y"
  2553. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2554. case 71:
  2555. # line 465 "awk.y"
  2556. { yyval.nodeval = make_param(yypvt[-0].sval); } break;
  2557. case 72:
  2558. # line 467 "awk.y"
  2559. { yyval.nodeval = append_right(yypvt[-2].nodeval, make_param(yypvt[-0].sval)); yyerrok; } break;
  2560. case 73:
  2561. # line 469 "awk.y"
  2562. { yyval.nodeval = NULL; } break;
  2563. case 74:
  2564. # line 471 "awk.y"
  2565. { yyval.nodeval = NULL; } break;
  2566. case 75:
  2567. # line 473 "awk.y"
  2568. { yyval.nodeval = NULL; } break;
  2569. case 76:
  2570. # line 479 "awk.y"
  2571. { yyval.nodeval = NULL; } break;
  2572. case 77:
  2573. # line 481 "awk.y"
  2574. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2575. case 78:
  2576. # line 486 "awk.y"
  2577. { yyval.nodeval = NULL; } break;
  2578. case 79:
  2579. # line 488 "awk.y"
  2580. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2581. case 80:
  2582. # line 493 "awk.y"
  2583. { yyval.nodeval = node (yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL); } break;
  2584. case 81:
  2585. # line 495 "awk.y"
  2586. {
  2587.         yyval.nodeval = append_right(yypvt[-2].nodeval,
  2588.             node( yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL));
  2589.         yyerrok;
  2590.       } break;
  2591. case 82:
  2592. # line 501 "awk.y"
  2593. { yyval.nodeval = NULL; } break;
  2594. case 83:
  2595. # line 503 "awk.y"
  2596. { yyval.nodeval = NULL; } break;
  2597. case 84:
  2598. # line 505 "awk.y"
  2599. { yyval.nodeval = NULL; } break;
  2600. case 85:
  2601. # line 507 "awk.y"
  2602. { yyval.nodeval = NULL; } break;
  2603. case 86:
  2604. # line 512 "awk.y"
  2605. { yyval.nodeval = NULL; } break;
  2606. case 87:
  2607. # line 514 "awk.y"
  2608. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2609. case 88:
  2610. # line 519 "awk.y"
  2611. { yyval.nodeval = node (yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL); } break;
  2612. case 89:
  2613. # line 521 "awk.y"
  2614. {
  2615.             yyval.nodeval = append_right(yypvt[-2].nodeval,
  2616.                 node( yypvt[-0].nodeval, Node_expression_list, (NODE *)NULL));
  2617.             yyerrok;
  2618.         } break;
  2619. case 90:
  2620. # line 527 "awk.y"
  2621. { yyval.nodeval = NULL; } break;
  2622. case 91:
  2623. # line 529 "awk.y"
  2624. { yyval.nodeval = NULL; } break;
  2625. case 92:
  2626. # line 531 "awk.y"
  2627. { yyval.nodeval = NULL; } break;
  2628. case 93:
  2629. # line 533 "awk.y"
  2630. { yyval.nodeval = NULL; } break;
  2631. case 94:
  2632. # line 538 "awk.y"
  2633. { want_assign = 0; } break;
  2634. case 95:
  2635. # line 540 "awk.y"
  2636. {
  2637.           if (do_lint && yypvt[-0].nodeval->type == Node_regex)
  2638.             warning("Regular expression on left of assignment.");
  2639.           yyval.nodeval = node (yypvt[-3].nodeval, yypvt[-2].nodetypeval, yypvt[-0].nodeval);
  2640.         } break;
  2641. case 96:
  2642. # line 546 "awk.y"
  2643. { yyval.nodeval = node (variable(yypvt[-0].sval,1), Node_in_array, yypvt[-3].nodeval); } break;
  2644. case 97:
  2645. # line 548 "awk.y"
  2646. {
  2647.           yyval.nodeval = node (yypvt[-0].nodeval, Node_K_getline,
  2648.              node (yypvt[-3].nodeval, Node_redirect_pipein, (NODE *)NULL));
  2649.         } break;
  2650. case 98:
  2651. # line 553 "awk.y"
  2652. {
  2653.           if (do_lint && ! io_allowed && yypvt[-0].nodeval == NULL)
  2654.             warning("non-redirected getline undefined inside BEGIN or END action");
  2655.           yyval.nodeval = node (yypvt[-1].nodeval, Node_K_getline, yypvt[-0].nodeval);
  2656.         } break;
  2657. case 99:
  2658. # line 559 "awk.y"
  2659. { yyval.nodeval = node (yypvt[-2].nodeval, Node_and, yypvt[-0].nodeval); } break;
  2660. case 100:
  2661. # line 561 "awk.y"
  2662. { yyval.nodeval = node (yypvt[-2].nodeval, Node_or, yypvt[-0].nodeval); } break;
  2663. case 101:
  2664. # line 563 "awk.y"
  2665. {
  2666.           if (yypvt[-2].nodeval->type == Node_regex)
  2667.             warning("Regular expression on left of MATCH operator.");
  2668.           yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, mk_rexp(yypvt[-0].nodeval));
  2669.         } break;
  2670. case 102:
  2671. # line 569 "awk.y"
  2672. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2673. case 103:
  2674. # line 571 "awk.y"
  2675. {
  2676.           yyval.nodeval = node(node(make_number(0.0),
  2677.                  Node_field_spec,
  2678.                  (NODE *) NULL),
  2679.                     Node_nomatch,
  2680.                 yypvt[-0].nodeval);
  2681.         } break;
  2682. case 104:
  2683. # line 579 "awk.y"
  2684. { yyval.nodeval = node (variable(yypvt[-0].sval,1), Node_in_array, yypvt[-2].nodeval); } break;
  2685. case 105:
  2686. # line 581 "awk.y"
  2687. {
  2688.           if (do_lint && yypvt[-0].nodeval->type == Node_regex)
  2689.             warning("Regular expression on left of comparison.");
  2690.           yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, yypvt[-0].nodeval);
  2691.         } break;
  2692. case 106:
  2693. # line 587 "awk.y"
  2694. { yyval.nodeval = node (yypvt[-2].nodeval, Node_less, yypvt[-0].nodeval); } break;
  2695. case 107:
  2696. # line 589 "awk.y"
  2697. { yyval.nodeval = node (yypvt[-2].nodeval, Node_greater, yypvt[-0].nodeval); } break;
  2698. case 108:
  2699. # line 591 "awk.y"
  2700. { yyval.nodeval = node(yypvt[-4].nodeval, Node_cond_exp, node(yypvt[-2].nodeval, Node_if_branches, yypvt[-0].nodeval));} break;
  2701. case 109:
  2702. # line 593 "awk.y"
  2703. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2704. case 110:
  2705. # line 595 "awk.y"
  2706. { yyval.nodeval = node (yypvt[-1].nodeval, Node_concat, yypvt[-0].nodeval); } break;
  2707. case 111:
  2708. # line 600 "awk.y"
  2709. { want_assign = 0; } break;
  2710. case 112:
  2711. # line 602 "awk.y"
  2712. { yyval.nodeval = node (yypvt[-3].nodeval, yypvt[-2].nodetypeval, yypvt[-0].nodeval); } break;
  2713. case 113:
  2714. # line 604 "awk.y"
  2715. { yyval.nodeval = node (yypvt[-2].nodeval, Node_and, yypvt[-0].nodeval); } break;
  2716. case 114:
  2717. # line 606 "awk.y"
  2718. { yyval.nodeval = node (yypvt[-2].nodeval, Node_or, yypvt[-0].nodeval); } break;
  2719. case 115:
  2720. # line 608 "awk.y"
  2721. {
  2722.           if (do_lint && ! io_allowed && yypvt[-0].nodeval == NULL)
  2723.             warning("non-redirected getline undefined inside BEGIN or END action");
  2724.           yyval.nodeval = node (yypvt[-1].nodeval, Node_K_getline, yypvt[-0].nodeval);
  2725.         } break;
  2726. case 116:
  2727. # line 614 "awk.y"
  2728. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2729. case 117:
  2730. # line 616 "awk.y"
  2731. { yyval.nodeval = node((NODE *) NULL, Node_nomatch, yypvt[-0].nodeval); } break;
  2732. case 118:
  2733. # line 618 "awk.y"
  2734. { yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, mk_rexp(yypvt[-0].nodeval)); } break;
  2735. case 119:
  2736. # line 620 "awk.y"
  2737. { yyval.nodeval = node (variable(yypvt[-0].sval,1), Node_in_array, yypvt[-2].nodeval); } break;
  2738. case 120:
  2739. # line 622 "awk.y"
  2740. { yyval.nodeval = node (yypvt[-2].nodeval, yypvt[-1].nodetypeval, yypvt[-0].nodeval); } break;
  2741. case 121:
  2742. # line 624 "awk.y"
  2743. { yyval.nodeval = node(yypvt[-4].nodeval, Node_cond_exp, node(yypvt[-2].nodeval, Node_if_branches, yypvt[-0].nodeval));} break;
  2744. case 122:
  2745. # line 626 "awk.y"
  2746. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2747. case 123:
  2748. # line 628 "awk.y"
  2749. { yyval.nodeval = node (yypvt[-1].nodeval, Node_concat, yypvt[-0].nodeval); } break;
  2750. case 126:
  2751. # line 636 "awk.y"
  2752. { yyval.nodeval = node (yypvt[-2].nodeval, Node_exp, yypvt[-0].nodeval); } break;
  2753. case 127:
  2754. # line 638 "awk.y"
  2755. { yyval.nodeval = node (yypvt[-2].nodeval, Node_times, yypvt[-0].nodeval); } break;
  2756. case 128:
  2757. # line 640 "awk.y"
  2758. { yyval.nodeval = node (yypvt[-2].nodeval, Node_quotient, yypvt[-0].nodeval); } break;
  2759. case 129:
  2760. # line 642 "awk.y"
  2761. { yyval.nodeval = node (yypvt[-2].nodeval, Node_mod, yypvt[-0].nodeval); } break;
  2762. case 130:
  2763. # line 644 "awk.y"
  2764. { yyval.nodeval = node (yypvt[-2].nodeval, Node_plus, yypvt[-0].nodeval); } break;
  2765. case 131:
  2766. # line 646 "awk.y"
  2767. { yyval.nodeval = node (yypvt[-2].nodeval, Node_minus, yypvt[-0].nodeval); } break;
  2768. case 132:
  2769. # line 651 "awk.y"
  2770. { yyval.nodeval = node (yypvt[-0].nodeval, Node_not,(NODE *) NULL); } break;
  2771. case 133:
  2772. # line 653 "awk.y"
  2773. { yyval.nodeval = yypvt[-1].nodeval; } break;
  2774. case 134:
  2775. # line 655 "awk.y"
  2776. { 
  2777.         if (! io_allowed && strcmp(tokstart, "nextfile") == 0)
  2778.             yyerror("nextfile() is illegal in BEGIN and END");
  2779.         } break;
  2780. case 135:
  2781. # line 660 "awk.y"
  2782. { yyval.nodeval = snode (yypvt[-1].nodeval, Node_builtin, (int) yypvt[-4].lval); } break;
  2783. case 136:
  2784. # line 662 "awk.y"
  2785. { yyval.nodeval = snode (yypvt[-1].nodeval, Node_builtin, (int) yypvt[-3].lval); } break;
  2786. case 137:
  2787. # line 664 "awk.y"
  2788. {
  2789.         if (do_lint)
  2790.             warning("call of `length' without parentheses is not portable");
  2791.         yyval.nodeval = snode ((NODE *)NULL, Node_builtin, (int) yypvt[-0].lval);
  2792.         if (do_posix)
  2793.             warning( "call of `length' without parentheses is deprecated by POSIX");
  2794.       } break;
  2795. case 138:
  2796. # line 672 "awk.y"
  2797. {
  2798.         yyval.nodeval = node (yypvt[-1].nodeval, Node_func_call, make_string(yypvt[-3].sval, strlen(yypvt[-3].sval)));
  2799.       } break;
  2800. case 139:
  2801. # line 676 "awk.y"
  2802. { yyval.nodeval = node (yypvt[-0].nodeval, Node_preincrement, (NODE *)NULL); } break;
  2803. case 140:
  2804. # line 678 "awk.y"
  2805. { yyval.nodeval = node (yypvt[-0].nodeval, Node_predecrement, (NODE *)NULL); } break;
  2806. case 141:
  2807. # line 680 "awk.y"
  2808. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2809. case 142:
  2810. # line 682 "awk.y"
  2811. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2812. case 143:
  2813. # line 685 "awk.y"
  2814. { if (yypvt[-0].nodeval->type == Node_val) {
  2815.             yypvt[-0].nodeval->numbr = -(force_number(yypvt[-0].nodeval));
  2816.             yyval.nodeval = yypvt[-0].nodeval;
  2817.           } else
  2818.             yyval.nodeval = node (yypvt[-0].nodeval, Node_unary_minus, (NODE *)NULL);
  2819.         } break;
  2820. case 144:
  2821. # line 692 "awk.y"
  2822. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2823. case 145:
  2824. # line 697 "awk.y"
  2825. { yyval.nodeval = node (yypvt[-1].nodeval, Node_postincrement, (NODE *)NULL); } break;
  2826. case 146:
  2827. # line 699 "awk.y"
  2828. { yyval.nodeval = node (yypvt[-1].nodeval, Node_postdecrement, (NODE *)NULL); } break;
  2829. case 148:
  2830. # line 705 "awk.y"
  2831. { yyval.nodeval = NULL; } break;
  2832. case 149:
  2833. # line 707 "awk.y"
  2834. { yyval.nodeval = yypvt[-0].nodeval; } break;
  2835. case 150:
  2836. # line 712 "awk.y"
  2837. { yyval.nodeval = variable(yypvt[-0].sval,1); } break;
  2838. case 151:
  2839. # line 714 "awk.y"
  2840. {
  2841.         if (yypvt[-1].nodeval->rnode == NULL) {
  2842.             yyval.nodeval = node (variable(yypvt[-3].sval,1), Node_subscript, yypvt[-1].nodeval->lnode);
  2843.             freenode(yypvt[-1].nodeval);
  2844.         } else
  2845.             yyval.nodeval = node (variable(yypvt[-3].sval,1), Node_subscript, yypvt[-1].nodeval);
  2846.         } break;
  2847. case 152:
  2848. # line 722 "awk.y"
  2849. { yyval.nodeval = node (yypvt[-0].nodeval, Node_field_spec, (NODE *)NULL); } break;
  2850. case 153:
  2851. # line 724 "awk.y"
  2852. { yyval.nodeval = node (yypvt[-0].nodeval, Node_field_spec, (NODE *)NULL); } break;
  2853. case 155:
  2854. # line 732 "awk.y"
  2855. { yyerrok; } break;
  2856. case 156:
  2857. # line 736 "awk.y"
  2858. { yyerrok; } break;
  2859. case 159:
  2860. # line 745 "awk.y"
  2861. { yyerrok; want_assign = 0; } break;
  2862. case 160:
  2863. # line 748 "awk.y"
  2864. { yyerrok; } break;
  2865.     }
  2866.     goto yystack;        /* reset registers in driver code */
  2867. }
  2868.